PLplot  5.13.0
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 4.0.0
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 
12 #ifndef SWIGOCTAVE
13 #define SWIGOCTAVE
14 #endif
15 
16 #define SWIG_name_d "plplot_octave"
17 #define SWIG_name plplot_octave
18 
19 #define SWIG_global_name "cvar"
20 #define SWIG_op_prefix "op_"
21 
22 
23 #ifdef __cplusplus
24 /* SwigValueWrapper is described in swig.swg */
25 template<typename T> class SwigValueWrapper {
26  struct SwigMovePointer {
27  T *ptr;
28  SwigMovePointer(T *p) : ptr(p) { }
29  ~SwigMovePointer() { delete ptr; }
30  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
31  } pointer;
32  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
33  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
34 public:
35  SwigValueWrapper() : pointer(0) { }
36  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
37  operator T&() const { return *pointer.ptr; }
38  T *operator&() { return pointer.ptr; }
39 };
40 
41 template <typename T> T SwigValueInit() {
42  return T();
43 }
44 #endif
45 
46 /* -----------------------------------------------------------------------------
47  * This section contains generic SWIG labels for method/variable
48  * declarations/attributes, and other compiler dependent labels.
49  * ----------------------------------------------------------------------------- */
50 
51 /* template workaround for compilers that cannot correctly implement the C++ standard */
52 #ifndef SWIGTEMPLATEDISAMBIGUATOR
53 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # elif defined(__HP_aCC)
56 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
57 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
58 # define SWIGTEMPLATEDISAMBIGUATOR template
59 # else
60 # define SWIGTEMPLATEDISAMBIGUATOR
61 # endif
62 #endif
63 
64 /* inline attribute */
65 #ifndef SWIGINLINE
66 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
67 # define SWIGINLINE inline
68 # else
69 # define SWIGINLINE
70 # endif
71 #endif
72 
73 /* attribute recognised by some compilers to avoid 'unused' warnings */
74 #ifndef SWIGUNUSED
75 # if defined(__GNUC__)
76 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
77 # define SWIGUNUSED __attribute__ ((__unused__))
78 # else
79 # define SWIGUNUSED
80 # endif
81 # elif defined(__ICC)
82 # define SWIGUNUSED __attribute__ ((__unused__))
83 # else
84 # define SWIGUNUSED
85 # endif
86 #endif
87 
88 #ifndef SWIG_MSC_UNSUPPRESS_4505
89 # if defined(_MSC_VER)
90 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
91 # endif
92 #endif
93 
94 #ifndef SWIGUNUSEDPARM
95 # ifdef __cplusplus
96 # define SWIGUNUSEDPARM(p)
97 # else
98 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
99 # endif
100 #endif
101 
102 /* internal SWIG method */
103 #ifndef SWIGINTERN
104 # define SWIGINTERN static SWIGUNUSED
105 #endif
106 
107 /* internal inline SWIG method */
108 #ifndef SWIGINTERNINLINE
109 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
110 #endif
111 
112 /* exporting methods */
113 #if defined(__GNUC__)
114 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
115 # ifndef GCC_HASCLASSVISIBILITY
116 # define GCC_HASCLASSVISIBILITY
117 # endif
118 # endif
119 #endif
120 
121 #ifndef SWIGEXPORT
122 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
123 # if defined(STATIC_LINKED)
124 # define SWIGEXPORT
125 # else
126 # define SWIGEXPORT __declspec(dllexport)
127 # endif
128 # else
129 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
130 # define SWIGEXPORT __attribute__ ((visibility("default")))
131 # else
132 # define SWIGEXPORT
133 # endif
134 # endif
135 #endif
136 
137 /* calling conventions for Windows */
138 #ifndef SWIGSTDCALL
139 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
140 # define SWIGSTDCALL __stdcall
141 # else
142 # define SWIGSTDCALL
143 # endif
144 #endif
145 
146 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
147 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
148 # define _CRT_SECURE_NO_DEPRECATE
149 #endif
150 
151 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
152 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
153 # define _SCL_SECURE_NO_DEPRECATE
154 #endif
155 
156 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
157 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
158 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
159 #endif
160 
161 /* Intel's compiler complains if a variable which was never initialised is
162  * cast to void, which is a common idiom which we use to indicate that we
163  * are aware a variable isn't used. So we just silence that warning.
164  * See: https://github.com/swig/swig/issues/192 for more discussion.
165  */
166 #ifdef __INTEL_COMPILER
167 # pragma warning disable 592
168 #endif
169 
170 
171 
172 #include <cstdlib>
173 #include <iostream>
174 
175 #include <octave/oct.h>
176 #include <octave/version.h>
177 
178 // Macro for enabling features which require Octave version >= major.minor.patch
179 // - Use (OCTAVE_PATCH_VERSION + 0) to handle both '<digit>' (released) and '<digit>+' (in development) patch numbers
180 #define SWIG_OCTAVE_PREREQ(major, minor, patch) \
181  ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
182 
183 // Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
184 #if !defined(OCTAVE_MAJOR_VERSION)
185 
186 # if !defined(OCTAVE_API_VERSION_NUMBER)
187 
188 // Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
189 // introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
190 # include <octave/ov.h>
191 # if defined(octave_ov_h)
192 # define OCTAVE_MAJOR_VERSION 3
193 # define OCTAVE_MINOR_VERSION 8
194 # define OCTAVE_PATCH_VERSION 0
195 # else
196 
197 // Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
198 # define ComplexLU __ignore
199 # include <octave/CmplxLU.h>
200 # undef ComplexLU
201 # if defined(octave_Complex_LU_h)
202 
203 // We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
204 # define OCTAVE_MAJOR_VERSION 3
205 # define OCTAVE_MINOR_VERSION 1
206 # define OCTAVE_PATCH_VERSION 99
207 
208 # else
209 
210 // OCTAVE_API_VERSION_NUMBER == 37
211 # define OCTAVE_MAJOR_VERSION 3
212 # define OCTAVE_MINOR_VERSION 2
213 # define OCTAVE_PATCH_VERSION 0
214 
215 # endif // defined(octave_Complex_LU_h)
216 
217 # endif // defined(octave_ov_h)
218 
219 // Correlation between Octave API and version numbers extracted from Octave's
220 // ChangeLogs; version is the *earliest* released Octave with that API number
221 # elif OCTAVE_API_VERSION_NUMBER >= 48
222 # define OCTAVE_MAJOR_VERSION 3
223 # define OCTAVE_MINOR_VERSION 6
224 # define OCTAVE_PATCH_VERSION 0
225 
226 # elif OCTAVE_API_VERSION_NUMBER >= 45
227 # define OCTAVE_MAJOR_VERSION 3
228 # define OCTAVE_MINOR_VERSION 4
229 # define OCTAVE_PATCH_VERSION 1
230 
231 # elif OCTAVE_API_VERSION_NUMBER >= 42
232 # define OCTAVE_MAJOR_VERSION 3
233 # define OCTAVE_MINOR_VERSION 3
234 # define OCTAVE_PATCH_VERSION 54
235 
236 # elif OCTAVE_API_VERSION_NUMBER >= 41
237 # define OCTAVE_MAJOR_VERSION 3
238 # define OCTAVE_MINOR_VERSION 3
239 # define OCTAVE_PATCH_VERSION 53
240 
241 # elif OCTAVE_API_VERSION_NUMBER >= 40
242 # define OCTAVE_MAJOR_VERSION 3
243 # define OCTAVE_MINOR_VERSION 3
244 # define OCTAVE_PATCH_VERSION 52
245 
246 # elif OCTAVE_API_VERSION_NUMBER >= 39
247 # define OCTAVE_MAJOR_VERSION 3
248 # define OCTAVE_MINOR_VERSION 3
249 # define OCTAVE_PATCH_VERSION 51
250 
251 # else // OCTAVE_API_VERSION_NUMBER == 38
252 # define OCTAVE_MAJOR_VERSION 3
253 # define OCTAVE_MINOR_VERSION 3
254 # define OCTAVE_PATCH_VERSION 50
255 
256 # endif // !defined(OCTAVE_API_VERSION_NUMBER)
257 
258 #endif // !defined(OCTAVE_MAJOR_VERSION)
259 
260 #include <octave/Cell.h>
261 #include <octave/dynamic-ld.h>
262 #include <octave/oct-env.h>
263 #include <octave/oct-map.h>
264 #include <octave/ov-scalar.h>
265 #include <octave/ov-fcn-handle.h>
266 #include <octave/parse.h>
267 #if SWIG_OCTAVE_PREREQ(4,2,0)
268 #include <octave/interpreter.h>
269 #else
270 #include <octave/toplev.h>
271 #endif
272 #include <octave/unwind-prot.h>
273 #if SWIG_OCTAVE_PREREQ(4,2,0)
274 #include <octave/call-stack.h>
275 #endif
276 
277 
278 /* -----------------------------------------------------------------------------
279  * swigrun.swg
280  *
281  * This file contains generic C API SWIG runtime support for pointer
282  * type checking.
283  * ----------------------------------------------------------------------------- */
284 
285 /* This should only be incremented when either the layout of swig_type_info changes,
286  or for whatever reason, the runtime changes incompatibly */
287 #define SWIG_RUNTIME_VERSION "4"
288 
289 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
290 #ifdef SWIG_TYPE_TABLE
291 # define SWIG_QUOTE_STRING(x) #x
292 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
293 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
294 #else
295 # define SWIG_TYPE_TABLE_NAME
296 #endif
297 
298 /*
299  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
300  creating a static or dynamic library from the SWIG runtime code.
301  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
302 
303  But only do this if strictly necessary, ie, if you have problems
304  with your compiler or suchlike.
305 */
306 
307 #ifndef SWIGRUNTIME
308 # define SWIGRUNTIME SWIGINTERN
309 #endif
310 
311 #ifndef SWIGRUNTIMEINLINE
312 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
313 #endif
314 
315 /* Generic buffer size */
316 #ifndef SWIG_BUFFER_SIZE
317 # define SWIG_BUFFER_SIZE 1024
318 #endif
319 
320 /* Flags for pointer conversions */
321 #define SWIG_POINTER_DISOWN 0x1
322 #define SWIG_CAST_NEW_MEMORY 0x2
323 
324 /* Flags for new pointer objects */
325 #define SWIG_POINTER_OWN 0x1
326 
327 
328 /*
329  Flags/methods for returning states.
330 
331  The SWIG conversion methods, as ConvertPtr, return an integer
332  that tells if the conversion was successful or not. And if not,
333  an error code can be returned (see swigerrors.swg for the codes).
334 
335  Use the following macros/flags to set or process the returning
336  states.
337 
338  In old versions of SWIG, code such as the following was usually written:
339 
340  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
341  // success code
342  } else {
343  //fail code
344  }
345 
346  Now you can be more explicit:
347 
348  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
349  if (SWIG_IsOK(res)) {
350  // success code
351  } else {
352  // fail code
353  }
354 
355  which is the same really, but now you can also do
356 
357  Type *ptr;
358  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
359  if (SWIG_IsOK(res)) {
360  // success code
361  if (SWIG_IsNewObj(res) {
362  ...
363  delete *ptr;
364  } else {
365  ...
366  }
367  } else {
368  // fail code
369  }
370 
371  I.e., now SWIG_ConvertPtr can return new objects and you can
372  identify the case and take care of the deallocation. Of course that
373  also requires SWIG_ConvertPtr to return new result values, such as
374 
375  int SWIG_ConvertPtr(obj, ptr,...) {
376  if (<obj is ok>) {
377  if (<need new object>) {
378  *ptr = <ptr to new allocated object>;
379  return SWIG_NEWOBJ;
380  } else {
381  *ptr = <ptr to old object>;
382  return SWIG_OLDOBJ;
383  }
384  } else {
385  return SWIG_BADOBJ;
386  }
387  }
388 
389  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
390  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
391  SWIG errors code.
392 
393  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
394  allows to return the 'cast rank', for example, if you have this
395 
396  int food(double)
397  int fooi(int);
398 
399  and you call
400 
401  food(1) // cast rank '1' (1 -> 1.0)
402  fooi(1) // cast rank '0'
403 
404  just use the SWIG_AddCast()/SWIG_CheckState()
405 */
406 
407 #define SWIG_OK (0)
408 #define SWIG_ERROR (-1)
409 #define SWIG_IsOK(r) (r >= 0)
410 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
411 
412 /* The CastRankLimit says how many bits are used for the cast rank */
413 #define SWIG_CASTRANKLIMIT (1 << 8)
414 /* The NewMask denotes the object was created (using new/malloc) */
415 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
416 /* The TmpMask is for in/out typemaps that use temporal objects */
417 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
418 /* Simple returning values */
419 #define SWIG_BADOBJ (SWIG_ERROR)
420 #define SWIG_OLDOBJ (SWIG_OK)
421 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
422 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
423 /* Check, add and del mask methods */
424 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
425 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
426 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
427 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
428 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
429 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
430 
431 /* Cast-Rank Mode */
432 #if defined(SWIG_CASTRANK_MODE)
433 # ifndef SWIG_TypeRank
434 # define SWIG_TypeRank unsigned long
435 # endif
436 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
437 # define SWIG_MAXCASTRANK (2)
438 # endif
439 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
440 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
441 SWIGINTERNINLINE int SWIG_AddCast(int r) {
442  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
443 }
445  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
446 }
447 #else /* no cast-rank mode */
448 # define SWIG_AddCast(r) (r)
449 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
450 #endif
451 
452 
453 #include <string.h>
454 
455 #ifdef __cplusplus
456 extern "C" {
457 #endif
458 
459 typedef void *(*swig_converter_func)(void *, int *);
460 typedef struct swig_type_info *(*swig_dycast_func)(void **);
461 
462 /* Structure to store information on one type */
463 typedef struct swig_type_info {
464  const char *name; /* mangled name of this type */
465  const char *str; /* human readable name of this type */
466  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
467  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
468  void *clientdata; /* language specific type data */
469  int owndata; /* flag if the structure owns the clientdata */
471 
472 /* Structure to store a type and conversion function used for casting */
473 typedef struct swig_cast_info {
474  swig_type_info *type; /* pointer to type that is equivalent to this type */
475  swig_converter_func converter; /* function to cast the void pointers */
476  struct swig_cast_info *next; /* pointer to next cast in linked list */
477  struct swig_cast_info *prev; /* pointer to the previous cast */
479 
480 /* Structure used to store module information
481  * Each module generates one structure like this, and the runtime collects
482  * all of these structures and stores them in a circularly linked list.*/
483 typedef struct swig_module_info {
484  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
485  size_t size; /* Number of types in this module */
486  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
487  swig_type_info **type_initial; /* Array of initially generated type structures */
488  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
489  void *clientdata; /* Language specific module data */
491 
492 /*
493  Compare two type names skipping the space characters, therefore
494  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
495 
496  Return 0 when the two name types are equivalent, as in
497  strncmp, but skipping ' '.
498 */
499 SWIGRUNTIME int
500 SWIG_TypeNameComp(const char *f1, const char *l1,
501  const char *f2, const char *l2) {
502  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
503  while ((*f1 == ' ') && (f1 != l1)) ++f1;
504  while ((*f2 == ' ') && (f2 != l2)) ++f2;
505  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
506  }
507  return (int)((l1 - f1) - (l2 - f2));
508 }
509 
510 /*
511  Check type equivalence in a name list like <name1>|<name2>|...
512  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
513 */
514 SWIGRUNTIME int
515 SWIG_TypeCmp(const char *nb, const char *tb) {
516  int equiv = 1;
517  const char* te = tb + strlen(tb);
518  const char* ne = nb;
519  while (equiv != 0 && *ne) {
520  for (nb = ne; *ne; ++ne) {
521  if (*ne == '|') break;
522  }
523  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
524  if (*ne) ++ne;
525  }
526  return equiv;
527 }
528 
529 /*
530  Check type equivalence in a name list like <name1>|<name2>|...
531  Return 0 if not equal, 1 if equal
532 */
533 SWIGRUNTIME int
534 SWIG_TypeEquiv(const char *nb, const char *tb) {
535  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
536 }
537 
538 /*
539  Check the typename
540 */
542 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
543  if (ty) {
544  swig_cast_info *iter = ty->cast;
545  while (iter) {
546  if (strcmp(iter->type->name, c) == 0) {
547  if (iter == ty->cast)
548  return iter;
549  /* Move iter to the top of the linked list */
550  iter->prev->next = iter->next;
551  if (iter->next)
552  iter->next->prev = iter->prev;
553  iter->next = ty->cast;
554  iter->prev = 0;
555  if (ty->cast) ty->cast->prev = iter;
556  ty->cast = iter;
557  return iter;
558  }
559  iter = iter->next;
560  }
561  }
562  return 0;
563 }
564 
565 /*
566  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
567 */
570  if (ty) {
571  swig_cast_info *iter = ty->cast;
572  while (iter) {
573  if (iter->type == from) {
574  if (iter == ty->cast)
575  return iter;
576  /* Move iter to the top of the linked list */
577  iter->prev->next = iter->next;
578  if (iter->next)
579  iter->next->prev = iter->prev;
580  iter->next = ty->cast;
581  iter->prev = 0;
582  if (ty->cast) ty->cast->prev = iter;
583  ty->cast = iter;
584  return iter;
585  }
586  iter = iter->next;
587  }
588  }
589  return 0;
590 }
591 
592 /*
593  Cast a pointer up an inheritance hierarchy
594 */
595 SWIGRUNTIMEINLINE void *
596 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
597  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
598 }
599 
600 /*
601  Dynamic pointer casting. Down an inheritance hierarchy
602 */
605  swig_type_info *lastty = ty;
606  if (!ty || !ty->dcast) return ty;
607  while (ty && (ty->dcast)) {
608  ty = (*ty->dcast)(ptr);
609  if (ty) lastty = ty;
610  }
611  return lastty;
612 }
613 
614 /*
615  Return the name associated with this type
616 */
617 SWIGRUNTIMEINLINE const char *
619  return ty->name;
620 }
621 
622 /*
623  Return the pretty name associated with this type,
624  that is an unmangled type name in a form presentable to the user.
625 */
626 SWIGRUNTIME const char *
628  /* The "str" field contains the equivalent pretty names of the
629  type, separated by vertical-bar characters. We choose
630  to print the last name, as it is often (?) the most
631  specific. */
632  if (!type) return NULL;
633  if (type->str != NULL) {
634  const char *last_name = type->str;
635  const char *s;
636  for (s = type->str; *s; s++)
637  if (*s == '|') last_name = s+1;
638  return last_name;
639  }
640  else
641  return type->name;
642 }
643 
644 /*
645  Set the clientdata field for a type
646 */
647 SWIGRUNTIME void
649  swig_cast_info *cast = ti->cast;
650  /* if (ti->clientdata == clientdata) return; */
651  ti->clientdata = clientdata;
652 
653  while (cast) {
654  if (!cast->converter) {
655  swig_type_info *tc = cast->type;
656  if (!tc->clientdata) {
658  }
659  }
660  cast = cast->next;
661  }
662 }
663 SWIGRUNTIME void
666  ti->owndata = 1;
667 }
668 
669 /*
670  Search for a swig_type_info structure only by mangled name
671  Search is a O(log #types)
672 
673  We start searching at module start, and finish searching when start == end.
674  Note: if start == end at the beginning of the function, we go all the way around
675  the circular list.
676 */
679  swig_module_info *end,
680  const char *name) {
681  swig_module_info *iter = start;
682  do {
683  if (iter->size) {
684  size_t l = 0;
685  size_t r = iter->size - 1;
686  do {
687  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
688  size_t i = (l + r) >> 1;
689  const char *iname = iter->types[i]->name;
690  if (iname) {
691  int compare = strcmp(name, iname);
692  if (compare == 0) {
693  return iter->types[i];
694  } else if (compare < 0) {
695  if (i) {
696  r = i - 1;
697  } else {
698  break;
699  }
700  } else if (compare > 0) {
701  l = i + 1;
702  }
703  } else {
704  break; /* should never happen */
705  }
706  } while (l <= r);
707  }
708  iter = iter->next;
709  } while (iter != end);
710  return 0;
711 }
712 
713 /*
714  Search for a swig_type_info structure for either a mangled name or a human readable name.
715  It first searches the mangled names of the types, which is a O(log #types)
716  If a type is not found it then searches the human readable names, which is O(#types).
717 
718  We start searching at module start, and finish searching when start == end.
719  Note: if start == end at the beginning of the function, we go all the way around
720  the circular list.
721 */
724  swig_module_info *end,
725  const char *name) {
726  /* STEP 1: Search the name field using binary search */
727  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
728  if (ret) {
729  return ret;
730  } else {
731  /* STEP 2: If the type hasn't been found, do a complete search
732  of the str field (the human readable name) */
733  swig_module_info *iter = start;
734  do {
735  size_t i = 0;
736  for (; i < iter->size; ++i) {
737  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
738  return iter->types[i];
739  }
740  iter = iter->next;
741  } while (iter != end);
742  }
743 
744  /* neither found a match */
745  return 0;
746 }
747 
748 /*
749  Pack binary data into a string
750 */
751 SWIGRUNTIME char *
752 SWIG_PackData(char *c, void *ptr, size_t sz) {
753  static const char hex[17] = "0123456789abcdef";
754  const unsigned char *u = (unsigned char *) ptr;
755  const unsigned char *eu = u + sz;
756  for (; u != eu; ++u) {
757  unsigned char uu = *u;
758  *(c++) = hex[(uu & 0xf0) >> 4];
759  *(c++) = hex[uu & 0xf];
760  }
761  return c;
762 }
763 
764 /*
765  Unpack binary data from a string
766 */
767 SWIGRUNTIME const char *
768 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
769  unsigned char *u = (unsigned char *) ptr;
770  const unsigned char *eu = u + sz;
771  for (; u != eu; ++u) {
772  char d = *(c++);
773  unsigned char uu;
774  if ((d >= '0') && (d <= '9'))
775  uu = (unsigned char)((d - '0') << 4);
776  else if ((d >= 'a') && (d <= 'f'))
777  uu = (unsigned char)((d - ('a'-10)) << 4);
778  else
779  return (char *) 0;
780  d = *(c++);
781  if ((d >= '0') && (d <= '9'))
782  uu |= (unsigned char)(d - '0');
783  else if ((d >= 'a') && (d <= 'f'))
784  uu |= (unsigned char)(d - ('a'-10));
785  else
786  return (char *) 0;
787  *u = uu;
788  }
789  return c;
790 }
791 
792 /*
793  Pack 'void *' into a string buffer.
794 */
795 SWIGRUNTIME char *
796 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
797  char *r = buff;
798  if ((2*sizeof(void *) + 2) > bsz) return 0;
799  *(r++) = '_';
800  r = SWIG_PackData(r,&ptr,sizeof(void *));
801  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
802  strcpy(r,name);
803  return buff;
804 }
805 
806 SWIGRUNTIME const char *
807 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
808  if (*c != '_') {
809  if (strcmp(c,"NULL") == 0) {
810  *ptr = (void *) 0;
811  return name;
812  } else {
813  return 0;
814  }
815  }
816  return SWIG_UnpackData(++c,ptr,sizeof(void *));
817 }
818 
819 SWIGRUNTIME char *
820 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
821  char *r = buff;
822  size_t lname = (name ? strlen(name) : 0);
823  if ((2*sz + 2 + lname) > bsz) return 0;
824  *(r++) = '_';
825  r = SWIG_PackData(r,ptr,sz);
826  if (lname) {
827  strncpy(r,name,lname+1);
828  } else {
829  *r = 0;
830  }
831  return buff;
832 }
833 
834 SWIGRUNTIME const char *
835 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
836  if (*c != '_') {
837  if (strcmp(c,"NULL") == 0) {
838  memset(ptr,0,sz);
839  return name;
840  } else {
841  return 0;
842  }
843  }
844  return SWIG_UnpackData(++c,ptr,sz);
845 }
846 
847 #ifdef __cplusplus
848 }
849 #endif
850 
851 /* Errors in SWIG */
852 #define SWIG_UnknownError -1
853 #define SWIG_IOError -2
854 #define SWIG_RuntimeError -3
855 #define SWIG_IndexError -4
856 #define SWIG_TypeError -5
857 #define SWIG_DivisionByZero -6
858 #define SWIG_OverflowError -7
859 #define SWIG_SyntaxError -8
860 #define SWIG_ValueError -9
861 #define SWIG_SystemError -10
862 #define SWIG_AttributeError -11
863 #define SWIG_MemoryError -12
864 #define SWIG_NullReferenceError -13
865 
866 
867 
868 #if !SWIG_OCTAVE_PREREQ(3,2,0)
869 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
870 #else
871 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
872 #endif
873 
874 SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
875  if (num_args > max_args && !varargs)
876  error("function %s takes at most %i arguments", func_name, max_args);
877  else if (num_args < min_args)
878  error("function %s requires at least %i arguments", func_name, min_args);
879  else
880  return true;
881  return false;
882 }
883 
884 SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
885  ovl->append(ov);
886  return ovl;
887 }
888 
889 SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
890  switch (code) {
891  case SWIG_MemoryError:
892  return "SWIG_MemoryError";
893  case SWIG_IOError:
894  return "SWIG_IOError";
895  case SWIG_RuntimeError:
896  return "SWIG_RuntimeError";
897  case SWIG_IndexError:
898  return "SWIG_IndexError";
899  case SWIG_TypeError:
900  return "SWIG_TypeError";
901  case SWIG_DivisionByZero:
902  return "SWIG_DivisionByZero";
903  case SWIG_OverflowError:
904  return "SWIG_OverflowError";
905  case SWIG_SyntaxError:
906  return "SWIG_SyntaxError";
907  case SWIG_ValueError:
908  return "SWIG_ValueError";
909  case SWIG_SystemError:
910  return "SWIG_SystemError";
911  case SWIG_AttributeError:
912  return "SWIG_AttributeError";
913  }
914  return "SWIG unknown error";
915 }
916 
917 SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
918  octave_value type(SWIG_ErrorType(code));
919  std::string r = msg;
920  r += " (" + type.string_value() + ")";
921  error(r.c_str());
922  return octave_value(r);
923 }
924 
925 #define SWIG_fail goto fail
926 
927 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
928 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
929 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
930 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
931 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
932 #define swig_owntype int
933 
934 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
935 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
936 
937 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
938 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
939 
940 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
941 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
942 
943 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
944 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
945 #define SWIG_MODULE_CLIENTDATA_TYPE void*
946 
947 #define Octave_Error_Occurred() 0
948 #define SWIG_Octave_AddErrorMsg(msg) {;}
949 
952 
953 // For backward compatibility only
954 #define SWIG_POINTER_EXCEPTION 0
955 #define SWIG_arg_fail(arg) 0
956 
957 // Runtime API implementation
958 
959 #include <map>
960 #include <vector>
961 #include <string>
962 
963 typedef octave_value_list(*octave_func) (const octave_value_list &, int);
964 class octave_swig_type;
965 
966 namespace Swig {
967 
968 #ifdef SWIG_DIRECTORS
969 
970  class Director;
971 
972  typedef std::map < void *, Director * > rtdir_map;
973  SWIGINTERN rtdir_map* get_rtdir_map();
974  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
975  SWIGINTERNINLINE void erase_rtdir(void *vptr);
976  SWIGINTERNINLINE Director *get_rtdir(void *vptr);
977 
978  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
979  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
980  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
981 
982 #endif
983 
984  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
986  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
987 }
988 
989 #ifdef SWIG_DIRECTORS
990 SWIGRUNTIME void swig_acquire_ownership(void *vptr);
991 SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
992 SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
993 #endif
994 
996  const char *name;
1000  int flags; // 1 static, 2 global
1001  const char *doc;
1002  bool is_static() const {
1003  return flags &1;
1004  } bool is_global() const {
1005  return flags &2;
1006  }
1007  };
1008 
1010  const char *name;
1014  const char *constructor_doc;
1017  const char **base_names;
1019  };
1020 
1021 #if SWIG_OCTAVE_PREREQ(4,4,0)
1022  // in Octave 4.4 behaviour of octave_builtin() appears to have changed and 'self' argument is no longer passed
1023  // to function (maybe because this is now a 'method'??) so need to create our own octave_function subclass
1024 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1025  class octave_swig_bound_func : public octave_function {
1026  public:
1027 
1028  octave_swig_bound_func(void) : octave_function(), method(0), first_args()
1029  { }
1030 
1031  octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1032  : octave_function("", ""), method(_method), first_args(_first_args)
1033  { }
1034 
1035  octave_swig_bound_func(const octave_swig_bound_func& f) = delete;
1036 
1037  octave_swig_bound_func& operator= (const octave_swig_bound_func& f) = delete;
1038 
1039  ~octave_swig_bound_func(void) = default;
1040 
1041  bool is_function(void) const { return true; }
1042 
1043  octave_function* function_value(bool = false) { return this; }
1044 
1045  octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1046  octave_value_list all_args;
1047  all_args.append(first_args);
1048  all_args.append(args);
1049  return method->call(tw, nargout, all_args);
1050  }
1051 
1052  octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1053  octave_value_list ovl = subsref(ops, idx, 1);
1054  return ovl.length() ? ovl(0) : octave_value();
1055  }
1056 
1057  octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1058  assert(ops.size() > 0);
1059  assert(ops.size() == idx.size());
1060  if (ops != "(")
1061  error("invalid function call");
1062  octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1063  return call(tw, nargout, *idx.begin());
1064  }
1065 
1066  protected:
1067 
1068  octave_function* method;
1069  octave_value_list first_args;
1070 
1071  std::set<std::string> dispatch_classes;
1072 
1073  private:
1074 
1075  DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
1076  };
1077  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_bound_func, "octave_swig_bound_func", "octave_swig_bound_func");
1078 #else
1079 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1080 #endif
1081 
1082  // octave_swig_type plays the role of both the shadow class and the class
1083  // representation within Octave, since there is no support for classes.
1084  //
1085  // These should really be decoupled, with the class support added to Octave
1086  // and the shadow class given by an m-file script. That would dramatically
1087  // reduce the runtime complexity, and be more in line w/ other modules.
1088 
1089  class octave_swig_type:public octave_base_value {
1090  struct cpp_ptr {
1091  void *ptr;
1093  cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1094  }};
1095  typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1096 
1098 
1099  const swig_type_info *construct_type; // type of special type object
1100  std::vector < type_ptr_pair > types; // our c++ base classes
1101  int own; // whether we call c++ destructors when we die
1102 
1103  typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1104  typedef std::map < std::string, member_value_pair > member_map;
1107 
1109  if (!type->clientdata)
1110  return 0;
1112  const swig_octave_member *m;
1113  for (m = c->members; m->name; ++m)
1114  if (m->name == name)
1115  return m;
1116  for (int j = 0; c->base_names[j]; ++j) {
1117  if (!c->base[j]) {
1118  if (!module)
1119  module = SWIG_GetModule(0);
1120  assert(module);
1122  }
1123  if (!c->base[j])
1124  return 0;
1125  if ((m = find_member(c->base[j], name)))
1126  return m;
1127  }
1128  return 0;
1129  }
1130 
1131  member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1132  member_map::iterator it = members.find(name);
1133  if (it != members.end())
1134  return &it->second;
1135  const swig_octave_member *m;
1136  for (unsigned int j = 0; j < types.size(); ++j)
1137  if ((m = find_member(types[j].first, name)))
1138  return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1139  if (!insert_if_not_found)
1140  return 0;
1141  return &members[name];
1142  }
1143 
1145  if (!base) {
1146  for (unsigned int j = 0; j < types.size(); ++j) {
1147  assert(types[j].first->clientdata);
1148  swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1149  if (cj->name == name)
1150  return types[j].first;
1151  }
1152  return 0;
1153  }
1154  assert(base->clientdata);
1156  for (int j = 0; c->base_names[j]; ++j) {
1157  if (!c->base[j]) {
1158  if (!module)
1159  module = SWIG_GetModule(0);
1160  assert(module);
1162  }
1163  if (!c->base[j])
1164  return 0;
1165  assert(c->base[j]->clientdata);
1167  if (cj->name == name)
1168  return c->base[j];
1169  }
1170  return 0;
1171  }
1172 
1173  void load_members(const swig_octave_class* c,member_map& out) const {
1174  for (const swig_octave_member *m = c->members; m->name; ++m) {
1175  if (out.find(m->name) == out.end())
1176  out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1177  }
1178  for (int j = 0; c->base_names[j]; ++j) {
1179  if (!c->base[j]) {
1180  if (!module)
1181  module = SWIG_GetModule(0);
1182  assert(module);
1184  }
1185  if (!c->base[j])
1186  continue;
1187  assert(c->base[j]->clientdata);
1188  const swig_octave_class *cj =
1189  (const swig_octave_class *) c->base[j]->clientdata;
1190  load_members(cj,out);
1191  }
1192  }
1193 
1194  void load_members(member_map& out) const {
1195  out=members;
1196  for (unsigned int j = 0; j < types.size(); ++j)
1197  if (types[j].first->clientdata)
1198  load_members((const swig_octave_class *) types[j].first->clientdata, out);
1199  }
1200 
1201  octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1202  if (m->second.is_defined())
1203  return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1204  else if (m->first && m->first->method)
1205  return m->first->method(args, nargout);
1206  error("member not defined or not invocable");
1207  return octave_value_list();
1208  }
1209 
1210  bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
1211  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1212  member_value_pair *m = nc_this->find_member(symbol, false);
1213  if (!m || m->first->is_static() || m->first->is_global())
1214  return false;
1215  octave_value_list args;
1216  args.append(nc_this->as_value());
1217  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1218  if (argout.length() < 1)
1219  return false;
1220  ret = argout(0);
1221  return true;
1222  }
1223 
1224  bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
1225  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1226  member_value_pair *m = nc_this->find_member(symbol, false);
1227  if (!m || m->first->is_static() || m->first->is_global())
1228  return false;
1229  octave_value_list args;
1230  args.append(nc_this->as_value());
1231  args.append(make_value_hack(rhs));
1232  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1233  if (argout.length() < 1)
1234  return false;
1235  ret = argout(0);
1236  return true;
1237  }
1238 
1239  bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
1240  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1241  member_value_pair *m = nc_this->find_member(symbol, false);
1242  if (!m || m->first->is_static() || m->first->is_global())
1243  return false;
1244  octave_value_list args;
1245  args.append(nc_this->as_value());
1246  args.append(rhs);
1247  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1248  if (argout.length() >= 1)
1249  ret = argout(0);
1250  return true;
1251  }
1252 
1253  octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1254  if (m->second.is_defined()) {
1255  if (m->second.is_function() || m->second.is_function_handle()) {
1256  return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args);
1257  } else {
1258  return m->second;
1259  }
1260  } else if (m->first) {
1261  if (m->first->get_method)
1262  return m->first->get_method(args, 1);
1263  else if (m->first->method)
1264  return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args);
1265  }
1266  error("undefined member");
1267  return octave_value_list();
1268  }
1269 
1270  static octave_value make_value_hack(const octave_base_value &x) {
1271  ((octave_swig_type &) x).count++;
1272  return octave_value((octave_base_value *) &x);
1273  }
1274 
1277  public:
1278 
1279  octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1280  bool _always_static = false)
1281  : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1282  always_static(_always_static) {
1283  if (_type || _ptr)
1284  types.push_back(std::make_pair(_type, _ptr));
1285 #ifdef SWIG_DIRECTORS
1286  if (_ptr) {
1287  Swig::Director *d = Swig::get_rtdir(_ptr);
1288  if (d)
1289  Swig::swig_director_set_self(d, this);
1290  }
1291 #endif
1292  }
1293 
1295  if (own) {
1296  ++count;
1297  for (unsigned int j = 0; j < types.size(); ++j) {
1298  if (!types[j].first || !types[j].first->clientdata)
1299  continue;
1300  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1301  if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1302  c->destructor(as_value(), 0);
1303  }
1304  }
1305  }
1306 #ifdef SWIG_DIRECTORS
1307  for (unsigned int j = 0; j < types.size(); ++j)
1308  Swig::erase_rtdir(types[j].second.ptr);
1309 #endif
1310  }
1311 
1312  dim_vector dims(void) const {
1313  octave_value out;
1314  if (!dispatch_unary_op("__dims__", out))
1315  return dim_vector(1,1);
1316 
1317  // Return value should be cell or matrix of integers
1318 #if SWIG_OCTAVE_PREREQ(4,4,0)
1319  if (out.iscell()) {
1320 #else
1321  if (out.is_cell()) {
1322 #endif
1323  const Cell & c=out.cell_value();
1324  int ndim = c.rows();
1325  if (ndim==1 && c.columns()!=1) ndim = c.columns();
1326 
1327  dim_vector d;
1328  d.resize(ndim < 2 ? 2 : ndim);
1329  d(0) = d(1) = 1;
1330 
1331  // Fill in dim_vector
1332  for (int k=0;k<ndim;k++) {
1333  const octave_value& obj = c(k);
1334  d.elem(k) = obj.int_value();
1335 
1336  // __dims__ should return a cell filled with integers
1337  if (error_state) return dim_vector(1,1);
1338  }
1339  return d;
1340 #if SWIG_OCTAVE_PREREQ(4,4,0)
1341  } else if (out.is_matrix_type() || out.isnumeric() ) {
1342 #else
1343  } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1344 #endif
1345  if (out.rows()==1 || out.columns()==1) {
1346  Array<int> a = out.int_vector_value();
1347  if (error_state) return dim_vector(1,1);
1348  dim_vector d;
1349  d.resize(a.numel() < 2 ? 2 : a.numel());
1350  d(0) = d(1) = 1;
1351  for (int k=0;k<a.numel();k++) {
1352  d.elem(k) = a(k);
1353  }
1354  return d;
1355  } else {
1356  return dim_vector(1,1);
1357  }
1358  } else {
1359  return dim_vector(1,1);
1360  }
1361  }
1362 
1363  octave_value as_value() {
1364  ++count;
1365  return Swig::swig_value_ref(this);
1366  }
1367 
1368  void incref() {
1369  ++count;
1370  }
1371 
1372  void decref() {
1373  if (!--count)
1374  delete this;
1375  }
1376 
1377  long swig_this() const {
1378  if (!types.size())
1379  return (long) this;
1380  return (long) types[0].second.ptr;
1381  }
1382  const char* help_text() const {
1383  if (!types.size())
1384  return 0;
1385  if (!types[0].first->clientdata)
1386  return 0;
1387  swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1388  return c->constructor_doc;
1389  }
1390 
1392  // * need some way to manually name subclasses.
1393  // * eg optional first arg to subclass(), or named_subclass()
1394  std::string ret;
1395  for (unsigned int j = 0; j < types.size(); ++j) {
1396  if (j)
1397  ret += "_";
1398  if (types[j].first->clientdata) {
1399  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1400  ret += c->name;
1401  } else
1402  ret += types[j].first->name;
1403  }
1404  return ret;
1405  }
1406 
1408  rhs.own = 0;
1409  for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1410  assert(!rhs.types[j].second.destroyed);
1411 #ifdef SWIG_DIRECTORS
1412  Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1413  if (d)
1414  Swig::swig_director_set_self(d, this);
1415 #endif
1416  }
1417  types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1418  members.insert(rhs.members.begin(), rhs.members.end());
1419 #if SWIG_OCTAVE_PREREQ(4,4,0)
1420  assign(rhs.swig_type_name(), rhs.as_value());
1421 #else
1422  rhs.types.clear();
1423  rhs.members.clear();
1424 #endif
1425  }
1426 
1427  typedef member_map::const_iterator swig_member_const_iterator;
1430 
1431  int cast(void **vptr, swig_type_info *type, int *_own, int flags) {
1432  int res = SWIG_ERROR;
1433  if (_own)
1434  *_own = own;
1435  if (flags &SWIG_POINTER_DISOWN)
1436  own = 0;
1437  if (!type && types.size()) {
1438  if(vptr)
1439  *vptr = types[0].second.ptr;
1440  return SWIG_OK;
1441  }
1442  for (unsigned int j = 0; j < types.size(); ++j)
1443  if (type == types[j].first) {
1444  if(vptr)
1445  *vptr = types[j].second.ptr;
1446  return SWIG_OK;
1447  }
1448  for (unsigned int j = 0; j < types.size(); ++j) {
1449  swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1450  if (!tc)
1451  continue;
1452  if(vptr) {
1453  int newmemory = 0;
1454  *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1455  if (newmemory == SWIG_CAST_NEW_MEMORY) {
1456  assert(_own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1457  if (_own)
1458  *_own = *_own | SWIG_CAST_NEW_MEMORY;
1459  }
1460  }
1461  res = SWIG_OK;
1462  break;
1463  }
1464  return res;
1465  }
1466 
1467  bool is_owned() const {
1468  return own;
1469  }
1470 
1471 #ifdef SWIG_DIRECTORS
1472  void director_destroyed(Swig::Director *d) {
1473  bool found = false;
1474  for (unsigned int j = 0; j < types.size(); ++j) {
1475  Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1476  if (dj == d) {
1477  types[j].second.destroyed = true;
1478  found = true;
1479  }
1480  }
1481  assert(found);
1482  }
1483 #endif
1484 
1485  void assign(const std::string &name, const octave_value &ov) {
1486  members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1487  }
1488 
1489  void assign(const std::string &name, const swig_octave_member *m) {
1490  members[name] = std::make_pair(m, octave_value());
1491  }
1492 
1493  octave_base_value *clone() const {
1494  // pass-by-value is probably not desired, and is harder;
1495  // requires calling copy constructors of contained types etc.
1496  assert(0);
1497  *(int *) 0 = 0;
1498  return 0;
1499  }
1500 
1501  octave_base_value *empty_clone() const {
1502  return new octave_swig_type();
1503  }
1504 
1505  bool is_defined() const {
1506  return true;
1507  }
1508 
1509  virtual bool is_map() const {
1510  return true;
1511  }
1512 
1513  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1514  octave_value_list ovl = subsref(ops, idx, 1);
1515  return ovl.length()? ovl(0) : octave_value();
1516  }
1517 
1518  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1519  assert(ops.size() > 0);
1520  assert(ops.size() == idx.size());
1521 
1522  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1523  int skip = 0;
1524  octave_value_list sub_ovl;
1525 
1526  // constructor invocation
1527  if (ops[skip] == '(' && construct_type) {
1528  assert(construct_type->clientdata);
1530  if (!c->constructor) {
1531  error("cannot create instance");
1532  return octave_value_list();
1533  }
1534  octave_value_list args;
1535  if (c->director)
1536  args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1537  args.append(*idx_it++);
1538  ++skip;
1539  sub_ovl = c->constructor(args, nargout);
1540  }
1541  // member dereference or invocation
1542  else if (ops[skip] == '.') {
1543  std::string subname;
1544  const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1545  for (;;) {
1546  octave_value_list subname_ovl(*idx_it++);
1547  ++skip;
1548  assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1549  subname = subname_ovl(0).string_value();
1550 
1551  const swig_type_info *next_base = find_base(subname, base);
1552  if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1553  break;
1554  base = next_base;
1555  }
1556 
1557  member_value_pair tmp, *m = &tmp;
1558  if (!base || !(m->first = find_member(base, subname)))
1559  m = find_member(subname, false);
1560  if (!m) {
1561  error("member not found");
1562  return octave_value_list();
1563  }
1564 
1565  octave_value_list args;
1566  if (!always_static &&
1567  (!m->first || (!m->first->is_static() && !m->first->is_global())))
1568  args.append(as_value());
1569  if (skip < (int) ops.size() && ops[skip] == '(' &&
1570  ((m->first && m->first->method) || m->second.is_function() ||
1571  m->second.is_function_handle())) {
1572  args.append(*idx_it++);
1573  ++skip;
1574  sub_ovl = member_invoke(m, args, nargout);
1575  } else {
1576  sub_ovl = member_deref(m, args);
1577  }
1578  }
1579  // index operator
1580  else {
1581  if (ops[skip] == '(' || ops[skip] == '{') {
1582  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1583  octave_value_list args;
1584  args.append(*idx_it++);
1585  ++skip;
1586  if (!dispatch_index_op(op_name, args, sub_ovl)) {
1587  error("error evaluating index operator");
1588  return octave_value_list();
1589  }
1590  } else {
1591  error("unsupported subsref");
1592  return octave_value_list();
1593  }
1594  }
1595 
1596  if (skip >= (int) ops.size())
1597  return sub_ovl;
1598  if (sub_ovl.length() < 1) {
1599  error("bad subs ref");
1600  return octave_value_list();
1601  }
1602  return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1603  }
1604 
1605  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1606  assert(ops.size() > 0);
1607  assert(ops.size() == idx.size());
1608 
1609  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1610  int skip = 0;
1611 
1612  if (ops.size() > 1) {
1613  std::list < octave_value_list >::const_iterator last = idx.end();
1614  --last;
1615  std::list < octave_value_list > next_idx(idx.begin(), last);
1616  octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1617  next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1618  }
1619 
1620  else if (ops[skip] == '(' || ops[skip] == '{') {
1621  const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1622  member_value_pair *m = find_member(op_name, false);
1623  if (m) {
1624  octave_value_list args;
1625  args.append(as_value());
1626  args.append(*idx_it);
1627  args.append(rhs);
1628  member_invoke(m, args, 1);
1629  } else
1630  error("%s member not found", op_name);
1631  }
1632 
1633  else if (ops[skip] == '.') {
1634  octave_value_list subname_ovl(*idx_it++);
1635  ++skip;
1636  assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1637  std::string subname = subname_ovl(0).string_value();
1638 
1639  member_value_pair *m = find_member(subname, true);
1640  if (!m->first || !m->first->set_method) {
1641  m->first = 0;
1642  m->second = rhs;
1643  } else if (m->first->set_method) {
1644  octave_value_list args;
1645  if (!m->first->is_static() && !m->first->is_global())
1646  args.append(as_value());
1647  args.append(rhs);
1648  m->first->set_method(args, 1);
1649  } else
1650  error("member not assignable");
1651  } else
1652  error("unsupported subsasgn");
1653 
1654  return as_value();
1655  }
1656 
1657  virtual bool is_object() const {
1658  return true;
1659  }
1660 
1661  virtual bool is_string() const {
1662  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1663  return !!nc_this->find_member("__str__", false);
1664  }
1665 
1666  virtual std::string string_value(bool force = false) const {
1667  octave_value ret;
1668  if (!dispatch_unary_op("__str__", ret)) {
1669  error("__str__ method not defined");
1670  return std::string();
1671  }
1672  if (!ret.is_string()) {
1673  error("__str__ method did not return a string");
1674  return std::string();
1675  }
1676  return ret.string_value();
1677  }
1678 
1679  virtual double scalar_value(bool frc_str_conv = false) const {
1680  octave_value ret;
1681  if (!dispatch_unary_op("__float__", ret)) {
1682  error("__float__ method not defined");
1683  }
1684  return ret.scalar_value();
1685  }
1686 
1687 #if SWIG_OCTAVE_PREREQ(4,2,0)
1688  virtual octave_value as_double(void) const {
1689  octave_value ret;
1690  if (!dispatch_unary_op("__float__", ret)) {
1691  error("__float__ method not defined");
1692  }
1693  return ret.as_double();
1694  }
1695 
1696  virtual octave_value as_single(void) const {
1697  octave_value ret;
1698  if (!dispatch_unary_op("__float__", ret)) {
1699  error("__float__ method not defined");
1700  }
1701  return ret.as_single();
1702  }
1703 #endif
1704 
1705 #if SWIG_OCTAVE_PREREQ(3,8,0)
1706  virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
1707  const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
1708  octave_value ret;
1709  if (!dispatch_unary_op(opname, ret)) {
1710  error((opname + std::string(" method not found")).c_str());
1711  return octave_value();
1712  }
1713  return ret;
1714  }
1715 #endif
1716 
1717 #if SWIG_OCTAVE_PREREQ(3,3,52)
1718  virtual octave_map map_value() const {
1719  return octave_map();
1720  }
1721 #else
1722  virtual Octave_map map_value() const {
1723  return Octave_map();
1724  }
1725 #endif
1726 
1727  virtual string_vector map_keys() const {
1728  member_map tmp;
1729  load_members(tmp);
1730 
1731  string_vector keys(tmp.size());
1732  int k = 0;
1733  for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1734  keys(k++) = it->first;
1735 
1736  return keys;
1737  }
1738 
1739  virtual bool save_ascii (std::ostream& os) {
1740  return true;
1741  }
1742 
1743  virtual bool load_ascii (std::istream& is) {
1744  return true;
1745  }
1746 
1747  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1748  return true;
1749  }
1750 
1751  virtual bool load_binary (std::istream& is, bool swap,
1752  oct_mach_info::float_format fmt) {
1753  return true;
1754  }
1755 
1756 #if defined (HAVE_HDF5)
1757 # if SWIG_OCTAVE_PREREQ(4,0,0)
1758  virtual bool
1759  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
1760  return true;
1761  }
1762 
1763  virtual bool
1764  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
1765  return true;
1766  }
1767 # else
1768  virtual bool
1769  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1770  return true;
1771  }
1772 
1773  virtual bool
1774  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1775  return true;
1776  }
1777 # endif
1778 #endif
1779 
1780  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1781  return string_value();
1782  }
1783 
1784  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1785  return string_value();
1786  }
1787 
1788  static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1789  // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1790  // (rather than any module namespace).
1791 
1792  octave_function *fcn = is_valid_function(symbol, std::string(), false);
1793  if (!fcn)
1794  return false;
1795 #if SWIG_OCTAVE_PREREQ(4,4,0)
1796  octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1797  octave_value_list retval = fcn->call(tw, 1, args);
1798  if (retval.length() == 1)
1799  ret = retval(0);
1800 #else
1801  ret = fcn->do_multi_index_op(1, args)(0);
1802 #endif
1803  return true;
1804  }
1805 
1806  static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1808  assert(ost);
1809 
1810  octave_value ret;
1811  if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1812  return ret;
1813  std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1814  octave_value_list args;
1815  args.append(make_value_hack(x));
1816  if (dispatch_global_op(symbol, args, ret))
1817  return ret;
1818 
1819  error("could not dispatch unary operator");
1820  return octave_value();
1821  }
1822 
1823  static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1824  octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
1825  octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
1826 
1827  octave_value ret;
1828  if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1829  return ret;
1830  if (rhs_ost) {
1831  if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1832  if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1833  return ret;
1834  if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1835  return ret;
1836  }
1837  if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1838  return ret;
1839  }
1840 
1841  std::string symbol;
1842  octave_value_list args;
1843  args.append(make_value_hack(lhs));
1844  args.append(make_value_hack(rhs));
1845 
1846  symbol = SWIG_op_prefix;
1847  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1848  symbol += "_";
1849  symbol += op_name;
1850  symbol += "_";
1851  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1852  if (dispatch_global_op(symbol, args, ret))
1853  return ret;
1854 
1855  symbol = SWIG_op_prefix;
1856  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1857  symbol += "_";
1858  symbol += op_name;
1859  symbol += "_";
1860  symbol += "any";
1861  if (dispatch_global_op(symbol, args, ret))
1862  return ret;
1863 
1864  symbol = SWIG_op_prefix;
1865  symbol += "any";
1866  symbol += "_";
1867  symbol += op_name;
1868  symbol += "_";
1869  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1870  if (dispatch_global_op(symbol, args, ret))
1871  return ret;
1872 
1873  error("could not dispatch binary operator");
1874  return octave_value();
1875  }
1876 
1877 #if SWIG_OCTAVE_PREREQ(4,0,0)
1878  void print(std::ostream &os, bool pr_as_read_syntax = false)
1879 #else
1880  void print(std::ostream &os, bool pr_as_read_syntax = false) const
1881 #endif
1882  {
1883  if (is_string()) {
1884  os << string_value();
1885  return;
1886  }
1887 
1888  member_map tmp;
1889  load_members(tmp);
1890 
1891  indent(os);
1892  os << "{"; newline(os);
1893  increment_indent_level();
1894  for (unsigned int j = 0; j < types.size(); ++j) {
1895  indent(os);
1896  if (types[j].first->clientdata) {
1897  const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1898  os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1899  } else {
1900  os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1901  }
1902  }
1903  for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1904  indent(os);
1905  if (it->second.first) {
1906  const char *objtype = it->second.first->method ? "method" : "variable";
1907  const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1908  os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1909  assert(it->second.first->name == it->first);
1910  } else {
1911  os << it->first; newline(os);
1912  }
1913  }
1914  decrement_indent_level();
1915  indent(os);
1916  os << "}"; newline(os);
1917  }
1918  };
1919 
1920  // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1921  // will call clone() via make_unique() if there is more than one outstanding
1922  // reference to the lhs, and forces the clone's reference count to 1
1923  // (so you can't just increment your own count and return this).
1924  //
1925  // One way to fix this (without modifying Octave) is to add a level of
1926  // indirection such that clone copies ref-counted pointer and we keep
1927  // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1928  //
1929  // Supporting both pass-by-{ref,value} and toggling via %feature/option
1930  // might be nice.
1931 
1932  class octave_swig_ref:public octave_base_value {
1934  public:
1936  :ptr(_ptr) { }
1937 
1939  { if (ptr) ptr->decref(); }
1940 
1942  { return ptr; }
1943 
1944  octave_base_value *clone() const
1945  { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
1946 
1947  octave_base_value *empty_clone() const
1948  { return new octave_swig_ref(0); }
1949 
1950  dim_vector dims(void) const
1951  { return ptr->dims(); }
1952 
1953  bool is_defined() const
1954  { return ptr->is_defined(); }
1955 
1956  virtual bool is_map() const
1957  { return ptr->is_map(); }
1958 
1959  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
1960  { return ptr->subsref(ops, idx); }
1961 
1962  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
1963  { return ptr->subsref(ops, idx, nargout); }
1964 
1965  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
1966  { return ptr->subsasgn(ops, idx, rhs); }
1967 
1968  virtual bool is_object() const
1969  { return ptr->is_object(); }
1970 
1971  virtual bool is_string() const
1972  { return ptr->is_string(); }
1973 
1974  virtual std::string string_value(bool force = false) const
1975  { return ptr->string_value(force); }
1976 
1977  virtual double scalar_value(bool frc_str_conv = false) const
1978  { return ptr->scalar_value(frc_str_conv); }
1979 
1980 #if SWIG_OCTAVE_PREREQ(4,2,0)
1981  virtual octave_value as_double(void) const
1982  { return ptr->as_double(); }
1983 
1984  virtual octave_value as_single(void) const
1985  { return ptr->as_single(); }
1986 #endif
1987 
1988 #if SWIG_OCTAVE_PREREQ(3,8,0)
1989  virtual octave_value map(octave_base_value::unary_mapper_t umap) const
1990  { return ptr->map(umap); }
1991 #endif
1992 
1993 #if SWIG_OCTAVE_PREREQ(3,3,52)
1994  virtual octave_map map_value() const
1995  { return ptr->map_value(); }
1996 #else
1997  virtual Octave_map map_value() const
1998  { return ptr->map_value(); }
1999 #endif
2000 
2001  virtual string_vector map_keys() const
2002  { return ptr->map_keys(); }
2003 
2004  virtual bool save_ascii (std::ostream& os)
2005  { return ptr->save_ascii(os); }
2006 
2007  virtual bool load_ascii (std::istream& is)
2008  { return ptr->load_ascii(is); }
2009 
2010  virtual bool save_binary (std::ostream& os, bool& save_as_floats)
2011  { return ptr->save_binary(os, save_as_floats); }
2012 
2013  virtual bool load_binary (std::istream& is, bool swap,
2014  oct_mach_info::float_format fmt)
2015  { return ptr->load_binary(is, swap, fmt); }
2016 
2017 #if defined (HAVE_HDF5)
2018 # if SWIG_OCTAVE_PREREQ(4,0,0)
2019  virtual bool
2020  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
2021  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2022 
2023  virtual bool
2024  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
2025  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2026 # else
2027  virtual bool
2028  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
2029  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2030 
2031  virtual bool
2032  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
2033  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2034 # endif
2035 #endif
2036 
2037  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
2038  { return ptr->convert_to_str(pad, force, type); }
2039 
2040  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
2041  { return ptr->convert_to_str_internal(pad, force, type); }
2042 
2043 #if SWIG_OCTAVE_PREREQ(4,0,0)
2044  void print(std::ostream &os, bool pr_as_read_syntax = false)
2045 #else
2046  void print(std::ostream &os, bool pr_as_read_syntax = false) const
2047 #endif
2048  { return ptr->print(os, pr_as_read_syntax); }
2049 
2050  virtual type_conv_info numeric_conversion_function(void) const {
2051  return octave_base_value::type_conv_info (default_numeric_conversion_function,
2052  octave_scalar::static_type_id ());
2053  }
2054 
2055  private:
2056  static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
2057  const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
2058  return new octave_scalar(v.scalar_value());
2059  }
2060 
2061 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2063 #endif
2065  };
2066 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2068 #endif
2069  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
2070 
2071  class octave_swig_packed:public octave_base_value {
2073  std::vector < char > buf;
2074  public:
2075 
2076  octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
2077  : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
2078  }
2079 
2080  bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
2081  if (outtype && outtype != type)
2082  return false;
2083  assert(sz <= buf.size());
2084  std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
2085  return true;
2086  }
2087 
2088  octave_base_value *clone() const {
2089  return new octave_swig_packed(*this);
2090  }
2091 
2092  octave_base_value *empty_clone() const {
2093  return new octave_swig_packed();
2094  }
2095 
2096  bool is_defined() const {
2097  return true;
2098  }
2099 
2100 #if SWIG_OCTAVE_PREREQ(4,0,0)
2101  void print(std::ostream &os, bool pr_as_read_syntax = false)
2102 #else
2103  void print(std::ostream &os, bool pr_as_read_syntax = false) const
2104 #endif
2105  {
2106  indent(os);
2107  os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
2108  }
2109 
2110 
2111  virtual bool save_ascii (std::ostream& os) {
2112  return true;
2113  }
2114 
2115  virtual bool load_ascii (std::istream& is) {
2116  return true;
2117  }
2118 
2119  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
2120  return true;
2121  }
2122 
2123  virtual bool load_binary (std::istream& is, bool swap,
2124  oct_mach_info::float_format fmt) {
2125  return true;
2126  }
2127 
2128 #if defined (HAVE_HDF5)
2129 # if SWIG_OCTAVE_PREREQ(4,0,0)
2130  virtual bool
2131  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
2132  return true;
2133  }
2134 
2135  virtual bool
2136  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
2137  return true;
2138  }
2139 # else
2140  virtual bool
2141  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
2142  return true;
2143  }
2144 
2145  virtual bool
2146  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
2147  return true;
2148  }
2149 # endif
2150 #endif
2151 
2152  private:
2153 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2155 #endif
2157  };
2158 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2160 #endif
2161  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
2162 
2163  SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
2164  error("attempt to set immutable member variable");
2165  return octave_value_list();
2166  }
2167 
2169  const octave_value_list &ovl;
2170  int j;
2171 
2172  octave_value_ref(const octave_value_list &_ovl, int _j)
2173  :ovl(_ovl), j(_j) { }
2174 
2175  operator octave_value() const {
2176  return ovl(j);
2177  }
2178 
2179  octave_value operator*() const {
2180  return ovl(j);
2181  }
2182  };
2183 
2184 
2185 namespace Swig {
2186 
2187  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
2188  return new octave_swig_ref(ost);
2189  }
2190 
2192  if (
2193 #if SWIG_OCTAVE_PREREQ(4,4,0)
2194  ov.iscell()
2195 #else
2196  ov.is_cell()
2197 #endif
2198  && ov.rows() == 1 && ov.columns() == 1)
2199  ov = ov.cell_value()(0);
2200  return swig_value_deref(*ov.internal_rep());
2201  }
2202 
2203  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
2204  if (ov.type_id() != octave_swig_ref::static_type_id())
2205  return 0;
2206  const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2207  return osr->get_ptr();
2208  }
2209 
2210 }
2211 
2212 
2213 #define swig_unary_op(name) \
2214 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2215  return octave_swig_type::dispatch_unary_op(x,#name); \
2216 }
2217 #define swig_binary_op(name) \
2218 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2219  return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2220 }
2221 #if SWIG_OCTAVE_PREREQ(4,4,0)
2222 #define swigreg_unary_op(name) \
2223 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2224 typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2225 #else
2226 #define swigreg_unary_op(name) \
2227 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2228 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2229 #endif
2230 #if SWIG_OCTAVE_PREREQ(4,4,0)
2231 #define swigreg_binary_op(name) \
2232 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2233 typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2234 #else
2235 #define swigreg_binary_op(name) \
2236 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2237 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2238 #endif
2239 
2240  swig_unary_op(not);
2241  swig_unary_op(uplus);
2242  swig_unary_op(uminus);
2243  swig_unary_op(transpose);
2244  swig_unary_op(hermitian);
2245  swig_unary_op(incr);
2246  swig_unary_op(decr);
2247 
2248  swig_binary_op(add);
2249  swig_binary_op(sub);
2250  swig_binary_op(mul);
2251  swig_binary_op(div);
2252  swig_binary_op(pow);
2253  swig_binary_op(ldiv);
2254 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2255  swig_binary_op(lshift);
2256  swig_binary_op(rshift);
2257 #endif
2258  swig_binary_op(lt);
2259  swig_binary_op(le);
2260  swig_binary_op(eq);
2261  swig_binary_op(ge);
2262  swig_binary_op(gt);
2263  swig_binary_op(ne);
2264  swig_binary_op(el_mul);
2265  swig_binary_op(el_div);
2266  swig_binary_op(el_pow);
2267  swig_binary_op(el_ldiv);
2268  swig_binary_op(el_and);
2269  swig_binary_op(el_or);
2270 
2272 #if SWIG_OCTAVE_PREREQ(4,4,0)
2273  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2274 #endif
2275  swigreg_unary_op(not);
2276  swigreg_unary_op(uplus);
2277  swigreg_unary_op(uminus);
2278  swigreg_unary_op(transpose);
2279  swigreg_unary_op(hermitian);
2280  swigreg_unary_op(incr);
2281  swigreg_unary_op(decr);
2282  }
2283  SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2284 #if SWIG_OCTAVE_PREREQ(4,4,0)
2285  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2286 #endif
2287  swigreg_binary_op(add);
2288  swigreg_binary_op(sub);
2289  swigreg_binary_op(mul);
2290  swigreg_binary_op(div);
2291  swigreg_binary_op(pow);
2292  swigreg_binary_op(ldiv);
2293 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2294  swigreg_binary_op(lshift);
2295  swigreg_binary_op(rshift);
2296 #endif
2297  swigreg_binary_op(lt);
2298  swigreg_binary_op(le);
2299  swigreg_binary_op(eq);
2300  swigreg_binary_op(ge);
2301  swigreg_binary_op(gt);
2302  swigreg_binary_op(ne);
2303  swigreg_binary_op(el_mul);
2304  swigreg_binary_op(el_div);
2305  swigreg_binary_op(el_pow);
2306  swigreg_binary_op(el_ldiv);
2307  swigreg_binary_op(el_and);
2308  swigreg_binary_op(el_or);
2309  }
2311  // here we assume that tid are conseq integers increasing from zero, and
2312  // that our tid is the last one. might be better to have explicit string
2313  // list of types we should bind to, and use lookup_type to resolve their tid.
2314 
2315  SWIG_InstallUnaryOps(tid);
2316  SWIG_InstallBinaryOps(tid, tid);
2317  for (int j = 0; j < tid; ++j) {
2318  SWIG_InstallBinaryOps(j, tid);
2319  SWIG_InstallBinaryOps(tid, j);
2320  }
2321  }
2322 
2323 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2324  int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2325 
2326 #ifdef SWIG_DIRECTORS
2327  Swig::Director *d = Swig::get_rtdir(ptr);
2328  if (d && Swig::swig_director_get_self(d))
2329  return Swig::swig_director_get_self(d)->as_value();
2330 #endif
2331  return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2332 }
2333 
2334 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2335  if (
2336 #if SWIG_OCTAVE_PREREQ(4,4,0)
2337  ov.iscell()
2338 #else
2339  ov.is_cell()
2340 #endif
2341  && ov.rows() == 1 && ov.columns() == 1)
2342  ov = ov.cell_value()(0);
2343  if (!ov.is_defined() ||
2344  (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2345  if (ptr)
2346  *ptr = 0;
2347  return SWIG_OK;
2348  }
2349  if (ov.type_id() != octave_swig_ref::static_type_id())
2350  return SWIG_ERROR;
2351  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2352  octave_swig_type *ost = osr->get_ptr();
2353  return ost->cast(ptr, type, own, flags);
2354 }
2355 
2356 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2357  return new octave_swig_packed(type, (char *) ptr, sz);
2358 }
2359 
2360 SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2361  if (!ov.is_defined())
2362  return SWIG_ERROR;
2363  if (ov.type_id() != octave_swig_packed::static_type_id())
2364  return SWIG_ERROR;
2365  octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2366  return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2367 }
2368 
2369 SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2370  module_ns->assign(name, ov);
2371 }
2372 
2374 #if SWIG_OCTAVE_PREREQ(4,4,0)
2375  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2376  return symtab.global_varval(name);
2377 #else
2378  return get_global_value(name, true);
2379 #endif
2380 }
2381 
2383 #if SWIG_OCTAVE_PREREQ(4,4,0)
2384  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2385  symtab.global_assign(name, value);
2386 #else
2387  set_global_value(name, value);
2388 #endif
2389 }
2390 
2392 #if SWIG_OCTAVE_PREREQ(4,4,0)
2393  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2394  octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2395  symscope.assign(name, symtab.global_varval(name));
2396  symscope.mark_global(name);
2397 #else
2398 #if !SWIG_OCTAVE_PREREQ(3,2,0)
2399  link_to_global_variable(curr_sym_tab->lookup(name, true));
2400 #else
2401 #if !SWIG_OCTAVE_PREREQ(3,8,0)
2402  symbol_table::varref(name);
2403 #endif
2404  symbol_table::mark_global(name);
2405 #endif
2406 #endif
2407 }
2408 
2410  octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2411  if (!ov.is_defined() ||
2412  ov.type_id() != octave_swig_packed::static_type_id())
2413  return 0;
2414  const octave_swig_packed* osp =
2415  static_cast < const octave_swig_packed *> (ov.internal_rep());
2416  swig_module_info *pointer = 0;
2417  osp->copy(0, &pointer, sizeof(swig_module_info *));
2418  return pointer;
2419 }
2420 
2421 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2422  octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2424 }
2425 
2426 
2427 
2428 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2429 
2430 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2431 
2432 
2433 
2434 /* -------- TYPES TABLE (BEGIN) -------- */
2435 
2436 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2437 #define SWIGTYPE_p_char swig_types[1]
2438 #define SWIGTYPE_p_double swig_types[2]
2439 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2440 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2441 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2442 #define SWIGTYPE_p_int swig_types[6]
2443 #define SWIGTYPE_p_p_char swig_types[7]
2444 #define SWIGTYPE_p_unsigned_int swig_types[8]
2446 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2447 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2448 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2449 
2450 /* -------- TYPES TABLE (END) -------- */
2451 
2452 
2453 #define SWIGVERSION 0x040000
2454 #define SWIG_VERSION SWIGVERSION
2455 
2456 
2457 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2458 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2459 
2460 
2461 #include <stdexcept>
2462 
2463 
2464 // #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2465 #undef PACKAGE
2466 #undef VERSION
2467 
2468 #include "plplotP.h"
2469 
2470 // Temporary fix for problems with -fvisibility=hidden and octave headers.
2471 #ifdef OCTAVE_EXPORT
2472  #if defined ( __GNUC__ ) && __GNUC__ > 3
2473  #undef OCTAVE_EXPORT
2474  #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2475  #endif
2476 #endif
2477 
2478 
2479 
2480 // I hate global variables but this is the best way I can think of
2481 // to manage consistency checking among function arguments.
2482  static PLINT Alen = 0;
2483  static PLINT Xlen = 0, Ylen = 0;
2484 
2485 
2486 // Convenience functions copied from matwrap-based approach (currently
2487 // stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2488 // tricky scalar case and also adopted so that the resulting
2489 // swig-generated source code will look similar to the matwrap-generated
2490 // source code.
2491 
2492  inline int max( int a, int b )
2493  {
2494  return a >= b ? a : b;
2495  }
2496  inline int min( int a, int b )
2497  {
2498  return a >= b ? a : b;
2499  }
2500 
2501 //
2502 // Function to get the total length (rows*columns) of an octave object of
2503 // arbitrary type.
2504 // Arguments:
2505 // 1) The octave object.
2506 //
2507 // If the object is a scalar, the array length is 1.
2508 //
2509  static int
2510  _arraylen( const octave_value &o_obj )
2511  {
2512  return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2513  // max is necessary because sometimes
2514  // rows() or columns() return -1 or 0 for
2515  // scalars.
2516  }
2517 
2518 //
2519 // Function to get the number of dimensions of an object.
2520 //
2521  static int
2522  _n_dims( const octave_value &o_obj )
2523  {
2524  if ( max( o_obj.columns(), 1 ) > 1 )
2525  return 2;
2526  // max is necessary because sometimes
2527  // rows() or columns() return -1 or 0 for
2528  // scalars.
2529  else if ( max( o_obj.rows(), 1 ) > 1 )
2530  return 1;
2531  else
2532  return 0;
2533  }
2534 
2535 //
2536 // Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2537 //
2538  static inline int
2539  _dim( const octave_value &o_obj, int dim_idx )
2540  {
2541  if ( dim_idx == 0 )
2542  return max( o_obj.rows(), 0 );
2543  // max is necessary because sometimes
2544  // rows() or columns() return -1 or 0 for
2545  // scalars.
2546  else if ( dim_idx == 1 )
2547  return max( o_obj.columns(), 0 );
2548  else
2549  return 1;
2550  }
2551 
2552 //
2553 // The following function converts an array of doubles into some other
2554 // numeric type. Arguments:
2555 // 1) Where to store the result. The type is determined from the type of
2556 // this pointer.
2557 // 2) A vector of doubles to convert.
2558 // 3) The number of doubles.
2559 //
2560  template <class FLOAT>
2561  static inline void
2562  _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2563  {
2564  while ( n_el-- > 0 )
2565  *out_arr++ = (FLOAT) ( *in_arr++ );
2566  }
2567 
2568  template void _cvt_double_to( int *, double *, unsigned );
2569  template void _cvt_double_to( unsigned *, double *, unsigned );
2570  template void _cvt_double_to( long *, double *, unsigned );
2571  template void _cvt_double_to( unsigned long *, double *, unsigned );
2572  template void _cvt_double_to( short *, double *, unsigned );
2573  template void _cvt_double_to( unsigned short *, double *, unsigned );
2574  template void _cvt_double_to( float *, double *, unsigned );
2575  // Instantiate our templates. Octave uses
2576  // manual template instantiation.
2577 
2578 //
2579 // Convert an array of some other type into an array of doubles. Arguments:
2580 // 1) The array of objects of other type.
2581 // 2) The output array of doubles.
2582 // 3) The number of elements to convert.
2583 //
2584  template <class FLOAT>
2585  static inline void
2586  _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2587  {
2588  while ( n_el-- > 0 )
2589  *d_arr++ = double(*arr++);
2590  }
2591 
2592  template void _cvt_to_double( int *, double *, unsigned );
2593  template void _cvt_to_double( unsigned *, double *, unsigned );
2594  template void _cvt_to_double( long *, double *, unsigned );
2595  template void _cvt_to_double( unsigned long *, double *, unsigned );
2596  template void _cvt_to_double( short *, double *, unsigned );
2597  template void _cvt_to_double( unsigned short *, double *, unsigned );
2598  template void _cvt_to_double( float *, double *, unsigned );
2599  // Instantiate our templates. Octave uses
2600  // manual template instantiation.
2601 
2602 
2603  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2604  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2605  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2606  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2607  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2609  typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2610 
2611 
2612 #include <iostream>
2613 
2614  octave_function *fcnMapForm;
2616 
2617  void mapform_octave( PLINT n, PLFLT *x, PLFLT *y )
2618  {
2619  octave_idx_type i;
2620  octave_value_list functionArguments;
2621  octave_value_list retval;
2622 
2623  Matrix xin( n, 1 );
2624  Matrix yin( n, 1 );
2625  Matrix xout;
2626  Matrix yout;
2627 
2628  for ( i = 0; i < n; i++ )
2629  {
2630  xin( i, 0 ) = x[i];
2631  yin( i, 0 ) = y[i];
2632  }
2633 
2634  functionArguments( 0 ) = xin;
2635  functionArguments( 1 ) = yin;
2636 
2637  if ( fcnMapForm != NULL )
2638 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2639  retval = octave::feval( fcnMapForm, functionArguments, 1 );
2640 #else
2641  retval = feval( fcnMapForm, functionArguments, 1 );
2642 #endif
2643  else
2644 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2645  retval = octave::feval( nameMapForm, functionArguments, 1 );
2646 #else
2647  retval = feval( nameMapForm, functionArguments, 1 );
2648 #endif
2649 
2650  if ( retval.length() >= 2 )
2651  {
2652  xout = retval( 0 ).matrix_value();
2653  yout = retval( 1 ).matrix_value();
2654 
2655  for ( i = 0; i < n; i++ )
2656  {
2657  x[i] = xout( i, 0 );
2658  y[i] = yout( i, 0 );
2659  }
2660  }
2661  }
2662 
2663 
2664  octave_function *fcnLabelFunc;
2666 
2667  void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2668  {
2669  int i;
2670  octave_value_list functionArguments;
2671  octave_value_list retval;
2672 
2673  Matrix inAxis( 1, 1 );
2674  Matrix inValue( 1, 1 );
2675  inAxis( 0, 0 ) = axis;
2676  inValue( 0, 0 ) = value;
2677 
2678  functionArguments( 0 ) = inAxis;
2679  functionArguments( 1 ) = inValue;
2680 
2681  if ( fcnLabelFunc != NULL )
2682 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2683  retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2684 #else
2685  retval = feval( fcnLabelFunc, functionArguments, 1 );
2686 #endif
2687  else
2688 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2689  retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2690 #else
2691  retval = feval( nameLabelFunc, functionArguments, 1 );
2692 #endif
2693 
2694  strncpy( label, retval( 0 ).string_value().c_str(), length );
2695  }
2696 
2697 
2698  octave_function *fcnCoordTrans;
2700 
2701  void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2702  {
2703  octave_idx_type i;
2704  octave_value_list functionArguments;
2705  octave_value_list retval;
2706 
2707  Matrix xin( 1, 1 );
2708  Matrix yin( 1, 1 );
2709  Matrix xout;
2710  Matrix yout;
2711 
2712  xin( 0, 0 ) = x;
2713  yin( 0, 0 ) = y;
2714 
2715  functionArguments( 0 ) = xin;
2716  functionArguments( 1 ) = yin;
2717 
2718  if ( fcnCoordTrans != NULL )
2719 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2720  retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2721 #else
2722  retval = feval( fcnCoordTrans, functionArguments, 1 );
2723 #endif
2724  else
2725 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2726  retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2727 #else
2728  retval = feval( nameCoordTrans, functionArguments, 1 );
2729 #endif
2730 
2731  if ( retval.length() >= 2 )
2732  {
2733  xout = retval( 0 ).matrix_value();
2734  yout = retval( 1 ).matrix_value();
2735 
2736  *xt = xout( 0, 0 );
2737  *yt = yout( 0, 0 );
2738  }
2739  }
2740 
2741 
2742  void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2743  {
2744  PLINT i;
2745  printf( "nlegend =%d\n", nlegend );
2746  for ( i = 0; i < nlegend; i++ )
2747  {
2748  printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2749  printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2750  printf( "text[%d] =%s\n", i, text[i] );
2751  }
2752  }
2753 
2754 
2755 #include <limits.h>
2756 #if !defined(SWIG_NO_LLONG_MAX)
2757 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2758 # define LLONG_MAX __LONG_LONG_MAX__
2759 # define LLONG_MIN (-LLONG_MAX - 1LL)
2760 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2761 # endif
2762 #endif
2763 
2764 
2765  SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2766  {
2767  if (!ov.is_scalar_type())
2768  return SWIG_TypeError;
2769  if (ov.is_complex_scalar())
2770  return SWIG_TypeError;
2771  if (ov.is_double_type()||ov.is_single_type()) {
2772  double v=ov.double_value();
2773  if (v!=floor(v))
2774  return SWIG_TypeError;
2775  }
2776  if (val)
2777  *val = ov.long_value();
2778  return SWIG_OK;
2779  }
2780 
2781 
2782 SWIGINTERN int
2783 SWIG_AsVal_int (octave_value obj, int *val)
2784 {
2785  long v;
2786  int res = SWIG_AsVal_long (obj, &v);
2787  if (SWIG_IsOK(res)) {
2788  if ((v < INT_MIN || v > INT_MAX)) {
2789  return SWIG_OverflowError;
2790  } else {
2791  if (val) *val = static_cast< int >(v);
2792  }
2793  }
2794  return res;
2795 }
2796 
2797 
2798  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 )
2799  {
2800  PLGraphicsIn gin;
2801  int status; status = plGetCursor( &gin );
2802  *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2803  strncpy( string, gin.string, PL_MAXKEY - 1 );
2804  string[PL_MAXKEY - 1] = '\0';
2805 
2806  *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2807  return status;
2808  }
2809 
2810 
2811 SWIGINTERN int
2812 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2813 {
2814  if (
2815 #if SWIG_OCTAVE_PREREQ(4,4,0)
2816  ov.iscell()
2817 #else
2818  ov.is_cell()
2819 #endif
2820  && ov.rows() == 1 && ov.columns() == 1)
2821  ov = ov.cell_value()(0);
2822  if (!ov.is_string())
2823  return SWIG_TypeError;
2824 
2825  std::string str=ov.string_value();
2826  size_t len=str.size();
2827  char* cstr=(char*)str.c_str();
2828  if (alloc) {
2829  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
2830  *alloc = SWIG_NEWOBJ;
2831  } else if (cptr)
2832  *cptr = cstr;
2833  if (psize)
2834  *psize = len + 1;
2835  return SWIG_OK;
2836 }
2837 
2838 
2839 
2840 
2841 
2843  {
2844  return octave_value(value);
2845  }
2846 
2847 
2848 SWIGINTERNINLINE octave_value
2850 {
2851  return SWIG_From_long (value);
2852 }
2853 
2854 
2856  {
2857  return octave_value(value);
2858  }
2859 
2860 
2861 // Translates relative device coordinates to world coordinates.
2862  static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2863  {
2864  PLGraphicsIn gin;
2865  int st;
2866  gin.dX = x_in; gin.dY = y_in;
2867  st = plTranslateCursor( &gin );
2868  *x = gin.wX; *y = gin.wY;
2869  return st;
2870  }
2871 
2872 
2873  SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2874  {
2875  if (!ov.is_scalar_type())
2876  return SWIG_TypeError;
2877  if (ov.is_complex_scalar())
2878  return SWIG_TypeError;
2879  if (val)
2880  *val = ov.double_value();
2881  return SWIG_OK;
2882  }
2883 
2884 
2885 // Create 1d stripchart
2886 
2887  void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
2888  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2889  PLFLT xlpos, PLFLT ylpos,
2890  PLBOOL y_ascl, PLBOOL acc,
2891  PLINT colbox, PLINT collab,
2892  const PLINT *colline, const PLINT *styline,
2893  const char *legline1, const char *legline2, const char *legline3, const char *legline4,
2894  const char *labx, const char *laby, const char *labtop )
2895  {
2896  const char *legline[4];
2897  legline[0] = legline1; legline[1] = legline2;
2898  legline[2] = legline3; legline[3] = legline4;
2899  c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2900  xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2901  labx, laby, labtop );
2902  }
2903 
2904 
2905 // One more hack. As it is not possible (and would not be desirable) to pass
2906 // an Octave function to plcont(), I have defined three plcont():
2907 // plcont uses a defined here xform()
2908 // plcont0 uses pltr0()
2909 // plcont1 uses pltr1()
2910 // plcont2 uses pltr2()
2911 // plcont2p uses pltr2p()
2912 //
2913 // Also, as plplot expect vectorized bidimensional arrays, I provided a
2914 // f2c, which is a #define that does the necessary conversion.
2915 //
2916 
2917  void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
2918  {
2919  *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2920  *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2921  }
2922 
2923 // convert from Fortran like arrays (one vector), to C like 2D arrays
2924 
2925 #define f2c( f, ff, nx, ny ) \
2926  PLFLT * *ff; \
2927  ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2928  for ( int i = 0; i < nx; i++ ) { \
2929  ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2930  for ( int j = 0; j < ny; j++ ) \
2931  *( ff[i] + j ) = *( f + nx * j + i );}
2932 
2933 // simpler plcont() for use with xform()
2934 
2935  void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2936  PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2937  {
2938  f2c( f, ff, nx, ny );
2939  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
2940  }
2941 
2942 // plcont() for use with pltr0() NOT TESTED
2943 
2944  void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2945  PLINT ly, const PLFLT *clevel, PLINT nlevel )
2946  {
2947  f2c( f, ff, nx, ny );
2948  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
2949  }
2950 
2951 // plcont() for use with pltr1()
2952 
2953  void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2954  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2955  {
2956  PLcGrid grid1;
2957  grid1.nx = nx; grid1.ny = ny;
2958  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2959  f2c( f, ff, nx, ny );
2960  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
2961  }
2962 
2963 // plcont() for use with pltr2()
2964  void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2965  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2966  {
2967  PLcGrid2 grid2;
2968  f2c( xg, xgg, nx, ny );
2969  f2c( yg, ygg, nx, ny );
2970  grid2.nx = nx; grid2.ny = ny;
2971  grid2.xg = xgg; grid2.yg = ygg;
2972  f2c( f, ff, nx, ny );
2973  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2974  }
2975 
2976 // plcont() for use with pltr2p()
2977 
2978  void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2979  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2980  {
2981  PLcGrid2 grid2;
2982  f2c( xg, xgg, nx, ny );
2983  f2c( yg, ygg, nx, ny );
2984  grid2.nx = nx; grid2.ny = ny;
2985  grid2.xg = xgg; grid2.yg = ygg;
2986  f2c( f, ff, nx, ny );
2987  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2988  }
2989 
2990 
2991  void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
2992  const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
2993  PLFLT *zg, int type, PLFLT data )
2994  {
2995  f2c( zg, zgg, nptsx, nptsy );
2996  plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2997  for ( int i = 0; i < nptsx; i++ )
2998  for ( int j = 0; j < nptsy; j++ )
2999  *( zg + nptsx * j + i ) = zgg[i][j];
3000  }
3001 
3002 
3003 // Plots a mesh representation of the function z[x][y].
3004 
3005  void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3006  {
3007  f2c( z, zz, nx, ny );
3008  c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3009  }
3010 
3011 // Plots a mesh representation of the function z[x][y] with contour
3012 
3013  void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3014  {
3015  f2c( z, zz, nx, ny );
3016  c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3017  }
3018 
3019 
3020 // Plots a 3-d representation of the function z[x][y].
3021  void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3022  PLINT nx, PLINT ny, PLINT opt, PLINT side )
3023  {
3024  f2c( z, zz, nx, ny );
3025  c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3026  }
3027 
3028 // Plots a 3-d representation of the function z[x][y] with contour
3029  void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3030  PLINT nx, PLINT ny, PLINT opt,
3031  const PLFLT *clevel, PLINT nlevel )
3032  {
3033  f2c( z, zz, nx, ny );
3034  c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3035  }
3036 // Plots a 3-d representation of the function z[x][y] with contour with y
3037 // index limits
3038  void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3039  PLINT nx, PLINT ny, PLINT opt,
3040  const PLFLT * clevel, PLINT nlevel,
3041  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3042  {
3043  f2c( z, zz, nx, ny );
3044  c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3045  indexxmin, indexxmax, indexymin, indexymax );
3046  }
3047 
3048 
3049  void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3050  PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3051  {
3052  f2c( z, zz, nx, ny );
3053  c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3054  }
3055 
3056  void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3057  PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3058  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3059  {
3060  f2c( z, zz, nx, ny );
3061  c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3062  indexxmin, indexxmax, indexymin, indexymax );
3063  }
3064 
3065 
3066 // The same as in plcont. I have hardcoded the first function pointer
3067 // to plfill(). The second function pointer will use the same convention
3068 // as in plcont().
3069 //
3070 
3071 // the simpler plshade()
3072  void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3073  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3074  PLFLT shade_min, PLFLT shade_max,
3075  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3076  PLINT min_color, PLINT min_width,
3077  PLINT max_color, PLINT max_width,
3078  PLINT rectangular, PLFLT *tr )
3079  {
3080  f2c( a, aa, nx, ny );
3081  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3082  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3083  min_color, min_width, max_color, max_width,
3084  plfill, rectangular, xform, tr );
3085  }
3086 
3087 // plshade() for use with pltr1
3088  void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3089  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3090  PLFLT shade_min, PLFLT shade_max,
3091  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3092  PLINT min_color, PLINT min_width,
3093  PLINT max_color, PLINT max_width,
3094  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3095  {
3096  PLcGrid grid1;
3097  grid1.nx = nx; grid1.ny = ny;
3098  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3099  f2c( a, aa, nx, ny );
3100  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3101  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3102  min_color, min_width, max_color, max_width,
3103  plfill, rectangular, pltr1, &grid1 );
3104  }
3105 
3106 // plshade() for use with pltr2
3107  void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3108  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3109  PLFLT shade_min, PLFLT shade_max,
3110  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3111  PLINT min_color, PLINT min_width,
3112  PLINT max_color, PLINT max_width,
3113  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3114  {
3115  PLcGrid2 grid2;
3116  f2c( xg, xgg, nx, ny );
3117  f2c( yg, ygg, nx, ny );
3118  grid2.nx = nx; grid2.ny = ny;
3119  grid2.xg = xgg; grid2.yg = ygg;
3120  f2c( a, aa, nx, ny );
3121  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3122  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3123  min_color, min_width, max_color, max_width,
3124  plfill, rectangular, pltr2, &grid2 );
3125  }
3126 
3127 
3128 
3129  void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3130  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3131  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3132  PLINT cont_color, PLINT cont_width,
3133  PLINT rectangular )
3134  {
3135  f2c( a, aa, nx, ny );
3136  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3137  clevel, nlevel, fill_width, cont_color, cont_width,
3138  plfill, rectangular, NULL, NULL );
3139  }
3140 
3141  void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3142  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3143  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3144  PLINT cont_color, PLINT cont_width,
3145  PLINT rectangular, PLFLT *tr )
3146  {
3147  f2c( a, aa, nx, ny );
3148  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3149  clevel, nlevel, fill_width, cont_color, cont_width,
3150  plfill, rectangular, xform, tr );
3151  }
3152 
3153  void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3154  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3155  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3156  PLINT cont_color, PLINT cont_width,
3157  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3158  {
3159  PLcGrid grid1;
3160  grid1.nx = nx; grid1.ny = ny;
3161  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3162 
3163  f2c( a, aa, nx, ny );
3164  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3165  clevel, nlevel, fill_width, cont_color, cont_width,
3166  plfill, rectangular, pltr1, &grid1 );
3167  }
3168 
3169  void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3170  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3171  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3172  PLINT cont_color, PLINT cont_width,
3173  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3174  {
3175  PLcGrid2 grid2;
3176  f2c( xg, xgg, nx, ny );
3177  f2c( yg, ygg, nx, ny );
3178  grid2.nx = nx; grid2.ny = ny;
3179  grid2.xg = xgg; grid2.yg = ygg;
3180  f2c( a, aa, nx, ny );
3181  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3182  clevel, nlevel, fill_width, cont_color, cont_width,
3183  plfill, rectangular, pltr2, &grid2 );
3184  }
3185 
3186 
3187 // Plot an array of vector arrows - uses the same function pointer
3188 // convention as plcont
3189 
3190  void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3191  {
3192  f2c( u, uu, nx, ny );
3193  f2c( v, vv, nx, ny );
3194  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3195  }
3196 
3197 // plvect() for use with pltr1
3198  void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3199  {
3200  PLcGrid grid1;
3201  grid1.nx = nx; grid1.ny = ny;
3202  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3203  f2c( u, uu, nx, ny );
3204  f2c( v, vv, nx, ny );
3205  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3206  }
3207 
3208 // plvect() for use with pltr2
3209  void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3210  {
3211  PLcGrid2 grid2;
3212  f2c( xg, xgg, nx, ny );
3213  f2c( yg, ygg, nx, ny );
3214  grid2.nx = nx; grid2.ny = ny;
3215  grid2.xg = xgg; grid2.yg = ygg;
3216  f2c( u, uu, nx, ny );
3217  f2c( v, vv, nx, ny );
3218  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3219  }
3220 
3221 
3222 // Plot an image with distortion - uses the same function pointer
3223  void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3224  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3225  PLFLT zmin, PLFLT zmax,
3226  PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3227  {
3228  f2c( a, aa, nx, ny );
3229  plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3230  }
3231 
3232 // Plot an image with distortion - uses the same function pointer
3233 // convention as plcont
3234  void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3235  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3236  PLFLT zmin, PLFLT zmax,
3237  PLFLT valuemin, PLFLT valuemax )
3238  {
3239  f2c( a, aa, nx, ny );
3240  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3241  }
3242 
3243  void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3244  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3245  PLFLT zmin, PLFLT zmax,
3246  PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3247  {
3248  f2c( a, aa, nx, ny );
3249  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3250  }
3251 
3252 // plimagefr() for use with pltr1
3253  void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3254  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3255  PLFLT zmin, PLFLT zmax,
3256  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3257  {
3258  PLcGrid grid1;
3259  grid1.nx = nx + 1; grid1.ny = ny + 1;
3260  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3261  f2c( a, aa, nx, ny );
3262  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3263  }
3264 
3265 // plimagefr() for use with pltr2
3266  void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3267  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3268  PLFLT zmin, PLFLT zmax,
3269  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3270  {
3271  PLcGrid2 grid2;
3272  f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3273  f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3274  grid2.nx = nx + 1; grid2.ny = ny + 1;
3275  grid2.xg = xgg; grid2.yg = ygg;
3276  f2c( a, aa, nx, ny );
3277  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3278  }
3279 
3280 
3281 
3282  void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3283  PLINT opt, PLINT position, PLFLT x, PLFLT y,
3284  PLFLT x_length, PLFLT y_length,
3285  PLINT bg_color, PLINT bb_color, PLINT bb_style,
3286  PLFLT low_cap_color, PLFLT high_cap_color,
3287  PLINT cont_color, PLFLT cont_width,
3288  PLINT n_labels, const PLINT *label_opts, const char **label,
3289  PLINT n_axes, const char ** axis_opts,
3290  const PLFLT *ticks, const PLINT *sub_ticks,
3291  const PLINT *n_values, const PLFLT *a )
3292  {
3293  PLINT nx, ny, i;
3294  nx = n_axes;
3295  ny = -1;
3296  for ( i = 0; i < nx; i++ )
3297  if ( n_values[i] > ny )
3298  ny = n_values[i];
3299  f2c( a, aa, nx, ny );
3300  c_plcolorbar( p_colorbar_width, p_colorbar_height,
3301  opt, position, x, y,
3302  x_length, y_length,
3303  bg_color, bb_color, bb_style,
3304  low_cap_color, high_cap_color,
3305  cont_color, cont_width,
3306  n_labels, label_opts, label,
3307  n_axes, axis_opts,
3308  ticks, sub_ticks,
3309  n_values, aa );
3310  }
3311 
3312 
3313 
3314  SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3315  {
3316  if (!ov.is_scalar_type())
3317  return SWIG_TypeError;
3318  if (ov.is_complex_scalar())
3319  return SWIG_TypeError;
3320  if (ov.is_double_type()||ov.is_single_type()) {
3321  double v=ov.double_value();
3322  if (v<0)
3323  return SWIG_OverflowError;
3324  if (v!=floor(v))
3325  return SWIG_TypeError;
3326  }
3327  if (ov.is_int8_type()||ov.is_int16_type()||
3328  ov.is_int32_type()) {
3329  long v=ov.long_value();
3330  if (v<0)
3331  return SWIG_OverflowError;
3332  }
3333  if (ov.is_int64_type()) {
3334  long long v=ov.int64_scalar_value().value();
3335  if (v<0)
3336  return SWIG_OverflowError;
3337  }
3338  if (val)
3339  *val = ov.ulong_value();
3340  return SWIG_OK;
3341  }
3342 
3343 
3344 SWIGINTERN int
3345 SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3346 {
3347  unsigned long v;
3348  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3349  if (SWIG_IsOK(res)) {
3350  if ((v > UINT_MAX)) {
3351  return SWIG_OverflowError;
3352  } else {
3353  if (val) *val = static_cast< unsigned int >(v);
3354  }
3355  }
3356  return res;
3357 }
3358 
3359 
3361  {
3362  return octave_value(value);
3363  }
3364 
3365 
3366 SWIGINTERNINLINE octave_value
3368 {
3370 }
3371 
3372 
3373 SWIGINTERN int
3374 SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3375 {
3376  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3377  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3378  if (SWIG_IsOK(res)) {
3379  /* special case of single char conversion when we don't need space for NUL */
3380  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3381  if (csize <= size) {
3382  if (val) {
3383  if (csize) memcpy(val, cptr, csize*sizeof(char));
3384  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3385  }
3386  if (alloc == SWIG_NEWOBJ) {
3387  delete[] cptr;
3388  res = SWIG_DelNewMask(res);
3389  }
3390  return res;
3391  }
3392  if (alloc == SWIG_NEWOBJ) delete[] cptr;
3393  }
3394  return SWIG_TypeError;
3395 }
3396 
3397 
3400 {
3401  static int init = 0;
3402  static swig_type_info* info = 0;
3403  if (!init) {
3404  info = SWIG_TypeQuery("_p_char");
3405  init = 1;
3406  }
3407  return info;
3408 }
3409 
3410 
3411 SWIGINTERNINLINE octave_value
3412 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3413 {
3414  return std::string(carray,carray+size);
3415 }
3416 
3417 
3418 SWIGINTERN size_t
3419 SWIG_strnlen(const char* s, size_t maxlen)
3420 {
3421  const char *p;
3422  for (p = s; maxlen-- && *p; p++)
3423  ;
3424  return p - s;
3425 }
3426 
3427 
3428 SWIGINTERN int
3429 SWIG_AsVal_char (octave_value obj, char *val)
3430 {
3431  int res = SWIG_AsCharArray(obj, val, 1);
3432  if (!SWIG_IsOK(res)) {
3433  long v;
3434  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3435  if (SWIG_IsOK(res)) {
3436  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3437  if (val) *val = static_cast< char >(v);
3438  } else {
3439  res = SWIG_OverflowError;
3440  }
3441  }
3442  }
3443  return res;
3444 }
3445 
3446 static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3447 Specify viewport in absolute coordinates\n\
3448 \n\
3449 DESCRIPTION:\n\
3450 \n\
3451  Alternate routine to plvpor for setting up the viewport. This routine\n\
3452  should be used only if the viewport is required to have a definite\n\
3453  size in millimeters. The routine plgspa is useful for finding out the\n\
3454  size of the current subpage.\n\
3455 \n\
3456  Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3457 \n\
3458  This function is used in example 10.\n\
3459 \n\
3460 \n\
3461 \n\
3462 SYNOPSIS:\n\
3463 \n\
3464 plsvpa(xmin, xmax, ymin, ymax)\n\
3465 \n\
3466 ARGUMENTS:\n\
3467 \n\
3468  xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3469  viewport from the left-hand edge of the subpage in millimeters.\n\
3470 \n\
3471  xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3472  viewport from the left-hand edge of the subpage in millimeters.\n\
3473 \n\
3474  ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3475  viewport from the bottom edge of the subpage in millimeters.\n\
3476 \n\
3477  ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3478  from the bottom edge of the subpage in millimeters.\n\
3479 ";
3480 static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3481 Write text relative to viewport boundaries in 3D plots\n\
3482 \n\
3483 DESCRIPTION:\n\
3484 \n\
3485  Writes text at a specified position relative to the viewport\n\
3486  boundaries. Text may be written inside or outside the viewport, but\n\
3487  is clipped at the subpage boundaries. The reference point of a string\n\
3488  lies along a line passing through the string at half the height of a\n\
3489  capital letter. The position of the reference point along this line\n\
3490  is determined by just, and the position of the reference point\n\
3491  relative to the viewport is set by disp and pos.\n\
3492 \n\
3493  Redacted form: plmtex3(side, disp, pos, just, text)\n\
3494 \n\
3495  This function is used in example 28.\n\
3496 \n\
3497 \n\
3498 \n\
3499 SYNOPSIS:\n\
3500 \n\
3501 plmtex3(side, disp, pos, just, text)\n\
3502 \n\
3503 ARGUMENTS:\n\
3504 \n\
3505  side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3506  the side of the viewport along which the text is to be written.\n\
3507  The string should contain one or more of the following characters:\n\
3508  [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3509  only label the X axis, not both the X and Y axes. x: Label the X\n\
3510  axis.\n\
3511  y: Label the Y axis.\n\
3512  z: Label the Z axis.\n\
3513  p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3514  For X it is the axis that starts at y-min. For Y it is the\n\
3515  axis that starts at x-min.\n\
3516  s: Label the secondary axis.\n\
3517  v: Draw the text perpendicular to the axis.\n\
3518 \n\
3519 \n\
3520  disp (PLFLT, input) : Position of the reference point of string,\n\
3521  measured outwards from the specified viewport edge in units of the\n\
3522  current character height. Use negative disp to write within the\n\
3523  viewport.\n\
3524 \n\
3525  pos (PLFLT, input) : Position of the reference point of string\n\
3526  along the specified edge, expressed as a fraction of the length of\n\
3527  the edge.\n\
3528 \n\
3529  just (PLFLT, input) : Specifies the position of the string relative\n\
3530  to its reference point. If just=0. , the reference point is at\n\
3531  the left and if just=1. , it is at the right of the string. Other\n\
3532  values of just give intermediate justifications.\n\
3533 \n\
3534  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3535  written out.\n\
3536 ";
3537 static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3538 Set semitransparent cmap1 RGBA colors.\n\
3539 \n\
3540 DESCRIPTION:\n\
3541 \n\
3542  Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3543  RGBA vector values. This function also sets the number of cmap1\n\
3544  colors. N.B. Continuous cmap1 colors are indexed with a\n\
3545  floating-point index in the range from 0.0-1.0 which is linearly\n\
3546  transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3547  vectors in the range from 0 to\n\
3548  ncol1-1. So in order for this continuous color model to work\n\
3549  properly, it is the responsibility of the user of plscmap1 to insure\n\
3550  that these RGBA vectors are continuous functions of their integer\n\
3551  indices.\n\
3552 \n\
3553  Redacted form: plscmap1a(r, g, b, alpha)\n\
3554 \n\
3555  This function is used in example 31.\n\
3556 \n\
3557 \n\
3558 \n\
3559 SYNOPSIS:\n\
3560 \n\
3561 plscmap1a(r, g, b, alpha, ncol1)\n\
3562 \n\
3563 ARGUMENTS:\n\
3564 \n\
3565  r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3566  8-bit integers in the range from 0-255) the degree of red in the\n\
3567  color as a continuous function of the integer index of the vector.\n\
3568 \n\
3569  g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3570  8-bit integers in the range from 0-255) the degree of green in the\n\
3571  color as a continuous function of the integer index of the vector.\n\
3572 \n\
3573  b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3574  8-bit integers in the range from 0-255) the degree of blue in the\n\
3575  color as a continuous function of the integer index of the vector.\n\
3576 \n\
3577  alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3578  values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3579  completely transparent and 1.0 corresponds to completely opaque)\n\
3580  the alpha transparency of the color as a continuous function of\n\
3581  the integer index of the vector.\n\
3582 \n\
3583  ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3584  vectors.\n\
3585 ";
3586 static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3587 Select standard viewport\n\
3588 \n\
3589 DESCRIPTION:\n\
3590 \n\
3591  Selects the largest viewport within the subpage that leaves a standard\n\
3592  margin (left-hand margin of eight character heights, and a margin\n\
3593  around the other three sides of five character heights).\n\
3594 \n\
3595  Redacted form: plvsta()\n\
3596 \n\
3597  This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3598 \n\
3599 \n\
3600 \n\
3601 SYNOPSIS:\n\
3602 \n\
3603 plvsta()\n\
3604 ";
3605 static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3606 Switch to graphics screen\n\
3607 \n\
3608 DESCRIPTION:\n\
3609 \n\
3610  Sets an interactive device to graphics mode, used in conjunction with\n\
3611  pltext to allow graphics and text to be interspersed. On a device\n\
3612  which supports separate text and graphics windows, this command causes\n\
3613  control to be switched to the graphics window. If already in graphics\n\
3614  mode, this command is ignored. It is also ignored on devices which\n\
3615  only support a single window or use a different method for shifting\n\
3616  focus. See also pltext.\n\
3617 \n\
3618  Redacted form: plgra()\n\
3619 \n\
3620  This function is used in example 1.\n\
3621 \n\
3622 \n\
3623 \n\
3624 SYNOPSIS:\n\
3625 \n\
3626 plgra()\n\
3627 ";
3628 static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3629 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3630 \n\
3631 DESCRIPTION:\n\
3632 \n\
3633  Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3634  (see the PLplot documentation) index. Overwrites the previous color\n\
3635  value for the given index and, thus, does not result in any additional\n\
3636  allocation of space for colors.\n\
3637 \n\
3638  This function is used in example 30.\n\
3639 \n\
3640 \n\
3641 \n\
3642 SYNOPSIS:\n\
3643 \n\
3644 plscol0a(icol0, r, g, b, alpha)\n\
3645 \n\
3646 ARGUMENTS:\n\
3647 \n\
3648  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3649  number of colors (which is set by default, by plscmap0n, or even\n\
3650  by plscmap0).\n\
3651 \n\
3652  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3653  degree of red in the color.\n\
3654 \n\
3655  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3656  degree of green in the color.\n\
3657 \n\
3658  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3659  degree of blue in the color.\n\
3660 \n\
3661  alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3662  (0.0-1.0).\n\
3663 ";
3664 static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3665 Set y axis parameters\n\
3666 \n\
3667 DESCRIPTION:\n\
3668 \n\
3669  Identical to plsxax, except that arguments are flags for y axis. See\n\
3670  the description of plsxax for more detail.\n\
3671 \n\
3672  Redacted form: plsyax(digmax, digits)\n\
3673 \n\
3674  This function is used in examples 1, 14, and 31.\n\
3675 \n\
3676 \n\
3677 \n\
3678 SYNOPSIS:\n\
3679 \n\
3680 plsyax(digmax, digits)\n\
3681 \n\
3682 ARGUMENTS:\n\
3683 \n\
3684  digmax (PLINT, input) : Variable to set the maximum number of\n\
3685  digits for the y axis. If nonzero, the printed label will be\n\
3686  switched to a floating-point representation when the number of\n\
3687  digits exceeds digmax.\n\
3688 \n\
3689  digits (PLINT, input) : Field digits value. Currently, changing\n\
3690  its value here has no effect since it is set only by plbox or\n\
3691  plbox3. However, the user may obtain its value after a call to\n\
3692  either of these functions by calling plgyax.\n\
3693 ";
3694 static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3695 Returns 8-bit RGB values for given color index from cmap0\n\
3696 \n\
3697 DESCRIPTION:\n\
3698 \n\
3699  Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3700  PLplot documentation). Values are negative if an invalid color id is\n\
3701  given.\n\
3702 \n\
3703  Redacted form: plgcol0(icol0, r, g, b)\n\
3704 \n\
3705  This function is used in example 2.\n\
3706 \n\
3707 \n\
3708 \n\
3709 SYNOPSIS:\n\
3710 \n\
3711 plgcol0(icol0, r, g, b)\n\
3712 \n\
3713 ARGUMENTS:\n\
3714 \n\
3715  icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3716 \n\
3717  r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3718  value.\n\
3719 \n\
3720  g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3721  value.\n\
3722 \n\
3723  b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3724  value.\n\
3725 ";
3726 static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3727 Set seed for internal random number generator.\n\
3728 \n\
3729 DESCRIPTION:\n\
3730 \n\
3731  Set the seed for the internal random number generator. See plrandd for\n\
3732  further details.\n\
3733 \n\
3734  Redacted form: plseed(seed)\n\
3735 \n\
3736  This function is used in example 21.\n\
3737 \n\
3738 \n\
3739 \n\
3740 SYNOPSIS:\n\
3741 \n\
3742 plseed(seed)\n\
3743 \n\
3744 ARGUMENTS:\n\
3745 \n\
3746  seed (unsigned int, input) : Seed for random number generator.\n\
3747 ";
3748 static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
3749 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3750 \n\
3751 DESCRIPTION:\n\
3752 \n\
3753  When the implementation is completed this variant of plot3dc (see that\n\
3754  function\'s documentation for more details) should be suitable for the\n\
3755  case where the area of the x, y coordinate grid where z is defined can\n\
3756  be non-rectangular. The implementation is incomplete so the last 4\n\
3757  parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3758  indexymax; are currently ignored and the functionality is otherwise\n\
3759  identical to that of plot3dc.\n\
3760 \n\
3761  Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3762  indexymin, indexymax)\n\
3763 \n\
3764 \n\
3765  This function is not used in any example.\n\
3766 \n\
3767 \n\
3768 \n\
3769 SYNOPSIS:\n\
3770 \n\
3771 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3772 \n\
3773 ARGUMENTS:\n\
3774 \n\
3775  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3776  which the function is evaluated.\n\
3777 \n\
3778  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3779  which the function is evaluated.\n\
3780 \n\
3781  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3782  plot. Should have dimensions of\n\
3783  nx by\n\
3784  ny.\n\
3785 \n\
3786  nx (PLINT, input) : Number of x values at which the function is\n\
3787  evaluated.\n\
3788 \n\
3789  ny (PLINT, input) : Number of y values at which the function is\n\
3790  evaluated.\n\
3791 \n\
3792  opt (PLINT, input) : Determines the way in which the surface is\n\
3793  represented. To specify more than one option just add the options,\n\
3794  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3795  showing z as a function of x for each value of y[j] .\n\
3796  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3797  for each value of x[i] .\n\
3798  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3799  at which function is defined.\n\
3800  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3801  the z value being plotted. The color is used from the current\n\
3802  cmap1.\n\
3803  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3804  using parameters\n\
3805  nlevel and\n\
3806  clevel.\n\
3807  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3808  the borders of the plotted function.\n\
3809 \n\
3810 \n\
3811  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3812  levels.\n\
3813 \n\
3814  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3815 \n\
3816  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3817  corresponds to the first x index where z is defined.\n\
3818 \n\
3819  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3820  which corresponds (by convention) to one more than the last x\n\
3821  index value where z is defined.\n\
3822 \n\
3823  indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3824  values which all must be ≥ 0. These values are the first y index\n\
3825  where z is defined for a particular x index in the range from\n\
3826  indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3827  indexxmax.\n\
3828 \n\
3829  indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3830  values which all must be ≤ ny. These values correspond (by\n\
3831  convention) to one more than the last y index where z is defined\n\
3832  for a particular x index in the range from indexxmin to indexxmax\n\
3833  - 1. The dimension of indexymax is indexxmax.\n\
3834 ";
3835 static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3836 Get output file name\n\
3837 \n\
3838 DESCRIPTION:\n\
3839 \n\
3840  Gets the current output file name, if applicable.\n\
3841 \n\
3842  Redacted form: plgfnam(fnam)\n\
3843 \n\
3844  This function is used in example 31.\n\
3845 \n\
3846 \n\
3847 \n\
3848 SYNOPSIS:\n\
3849 \n\
3850 plgfnam(fnam)\n\
3851 \n\
3852 ARGUMENTS:\n\
3853 \n\
3854  fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3855  (with preallocated length of 80 characters or more) containing the\n\
3856  file name.\n\
3857 ";
3858 static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3859 Specify window\n\
3860 \n\
3861 DESCRIPTION:\n\
3862 \n\
3863  Specify the window, i.e., the world coordinates of the edges of the\n\
3864  viewport.\n\
3865 \n\
3866  Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3867 \n\
3868  This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3869  29, and 31.\n\
3870 \n\
3871 \n\
3872 \n\
3873 SYNOPSIS:\n\
3874 \n\
3875 plwind(xmin, xmax, ymin, ymax)\n\
3876 \n\
3877 ARGUMENTS:\n\
3878 \n\
3879  xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3880  of the viewport.\n\
3881 \n\
3882  xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3883  of the viewport.\n\
3884 \n\
3885  ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3886  the viewport.\n\
3887 \n\
3888  ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3889  viewport.\n\
3890 ";
3891 static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
3892 Set cmap1 colors using a piece-wise linear relationship\n\
3893 \n\
3894 DESCRIPTION:\n\
3895 \n\
3896  Set cmap1 colors using a piece-wise linear relationship between the\n\
3897  cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
3898  (see the PLplot documentation). May be called at any time.\n\
3899 \n\
3900  The idea here is to specify a number of control points that define the\n\
3901  mapping between input cmap1 intensity indices and HLS (or RGB).\n\
3902  Between these points, linear interpolation is used which gives a\n\
3903  smooth variation of color with intensity index. Any number of control\n\
3904  points may be specified, located at arbitrary positions, although\n\
3905  typically 2 - 4 are enough. Another way of stating this is that we are\n\
3906  traversing a given number of lines through HLS (or RGB) space as we\n\
3907  move through cmap1 intensity indices. The control points at the\n\
3908  minimum and maximum position (0 and 1) must always be specified. By\n\
3909  adding more control points you can get more variation. One good\n\
3910  technique for plotting functions that vary about some expected average\n\
3911  is to use an additional 2 control points in the center (position ~=\n\
3912  0.5) that are the same lightness as the background (typically white\n\
3913  for paper output, black for crt), and same hue as the boundary control\n\
3914  points. This allows the highs and lows to be very easily\n\
3915  distinguished.\n\
3916 \n\
3917  Each control point must specify the cmap1 intensity index and the\n\
3918  associated three coordinates in HLS or RGB space. The first point\n\
3919  must correspond to position = 0, and the last to position = 1.\n\
3920 \n\
3921  The default behaviour is for the hue to be linearly interpolated\n\
3922  between the control points. Since the hue lies in the range [0, 360]\n\
3923  this corresponds to interpolation around the \"front\" of the color\n\
3924  wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n\
3925  alternative interpolation is used between control points i and i+1. If\n\
3926  hue[i+1]-hue[i] > 0 then interpolation is between hue[i] and hue[i+1]\n\
3927  - 360, otherwise between hue[i] and hue[i+1] + 360. You can consider\n\
3928  this as interpolation around the \"back\" or \"reverse\" of the color\n\
3929  wheel. Specifying alt_hue_path=NULL is equivalent to setting\n\
3930  alt_hue_path[] = false for every control point.\n\
3931 \n\
3932  Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3933  240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3934  240]truegreen-yellow-red-magenta-blue[240\n\
3935  120]trueblue-magenta-red-yellow-green\n\
3936 \n\
3937  Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3938  1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3939  1]magnitudeHLSsaturation[0, 1]magnitude\n\
3940 \n\
3941  Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
3942  alt_hue_path)\n\
3943 \n\
3944  This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
3945 \n\
3946 \n\
3947 \n\
3948 SYNOPSIS:\n\
3949 \n\
3950 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
3951 \n\
3952 ARGUMENTS:\n\
3953 \n\
3954  itype (PLBOOL, input) : true: RGB, false: HLS.\n\
3955 \n\
3956  npts (PLINT, input) : number of control points\n\
3957 \n\
3958  intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
3959  intensity index (0.0-1.0) in ascending order for each control\n\
3960  point.\n\
3961 \n\
3962  coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
3963  coordinate (H or R) for each control point.\n\
3964 \n\
3965  coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
3966  coordinate (L or G) for each control point.\n\
3967 \n\
3968  coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
3969  coordinate (S or B) for each control point.\n\
3970 \n\
3971  alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
3972  npts - 1 elements) containing the alternative interpolation method\n\
3973  Boolean value for each control point interval. (alt_hue_path[i]\n\
3974  refers to the interpolation interval between the i and i + 1\n\
3975  control points).\n\
3976 ";
3977 static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
3978 Set the pause (on end-of-page) status\n\
3979 \n\
3980 DESCRIPTION:\n\
3981 \n\
3982  Set the pause (on end-of-page) status.\n\
3983 \n\
3984  Redacted form: plspause(pause)\n\
3985 \n\
3986  This function is in examples 14,20.\n\
3987 \n\
3988 \n\
3989 \n\
3990 SYNOPSIS:\n\
3991 \n\
3992 plspause(pause)\n\
3993 \n\
3994 ARGUMENTS:\n\
3995 \n\
3996  pause (PLBOOL, input) : If pause is true there will be a pause on\n\
3997  end-of-page for those drivers which support this. Otherwise there\n\
3998  is no pause.\n\
3999 ";
4000 static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
4001 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
4002 \n\
4003 DESCRIPTION:\n\
4004 \n\
4005  Routine for creating a discrete plot legend with a plotted filled box,\n\
4006  line, and/or line of symbols for each annotated legend entry. (See\n\
4007  plcolorbar for similar functionality for creating continuous color\n\
4008  bars.) The arguments of pllegend provide control over the location\n\
4009  and size of the legend as well as the location and characteristics of\n\
4010  the elements (most of which are optional) within that legend. The\n\
4011  resulting legend is clipped at the boundaries of the current subpage.\n\
4012  (N.B. the adopted coordinate system used for some of the parameters is\n\
4013  defined in the documentation of the position parameter.)\n\
4014 \n\
4015  Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
4016  position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
4017  ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
4018  test_justification, text_colors, text, box_colors, box_patterns,\n\
4019  box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
4020  symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
4021 \n\
4022  This function is used in examples 4, 26, and 33.\n\
4023 \n\
4024 \n\
4025 \n\
4026 SYNOPSIS:\n\
4027 \n\
4028 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\
4029 \n\
4030 ARGUMENTS:\n\
4031 \n\
4032  p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4033  legend width in adopted coordinates. This quantity is calculated\n\
4034  from plot_width, text_offset, ncolumn (possibly modified inside\n\
4035  the routine depending on nlegend and nrow), and the length\n\
4036  (calculated internally) of the longest text string.\n\
4037 \n\
4038  p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4039  legend height in adopted coordinates. This quantity is calculated\n\
4040  from text_scale, text_spacing, and nrow (possibly modified inside\n\
4041  the routine depending on nlegend and nrow).\n\
4042 \n\
4043  opt (PLINT, input) : opt contains bits controlling the overall\n\
4044  legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
4045  on the left of the legend and the plotted area on the right.\n\
4046  Otherwise, put the text area on the right of the legend and the\n\
4047  plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
4048  plot a (semitransparent) background for the legend. If the\n\
4049  PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
4050  legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
4051  possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
4052  plot the resulting array of legend entries in row-major order.\n\
4053  Otherwise, plot the legend entries in column-major order.\n\
4054 \n\
4055  position (PLINT, input) : position contains bits which control the\n\
4056  overall position of the legend and the definition of the adopted\n\
4057  coordinates used for positions just like what is done for the\n\
4058  position argument for plcolorbar. However, note that the defaults\n\
4059  for the position bits (see below) are different than the\n\
4060  plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
4061  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
4062  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
4063  the 16 possible standard positions (the 4 corners and centers of\n\
4064  the 4 sides for both the inside and outside cases) of the legend\n\
4065  relative to the adopted coordinate system. The corner positions\n\
4066  are specified by the appropriate combination of two of the\n\
4067  PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
4068  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
4069  value of one of those bits. The adopted coordinates are\n\
4070  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
4071  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
4072  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
4073  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
4074  then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
4075  If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
4076  use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
4077  PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
4078 \n\
4079  x (PLFLT, input) : X offset of the legend position in adopted\n\
4080  coordinates from the specified standard position of the legend.\n\
4081  For positive x, the direction of motion away from the standard\n\
4082  position is inward/outward from the standard corner positions or\n\
4083  standard left or right positions if the\n\
4084  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
4085  For the standard top or bottom positions, the direction of motion\n\
4086  is toward positive X.\n\
4087 \n\
4088  y (PLFLT, input) : Y offset of the legend position in adopted\n\
4089  coordinates from the specified standard position of the legend.\n\
4090  For positive y, the direction of motion away from the standard\n\
4091  position is inward/outward from the standard corner positions or\n\
4092  standard top or bottom positions if the\n\
4093  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
4094  the standard left or right positions, the direction of motion is\n\
4095  toward positive Y.\n\
4096 \n\
4097  plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
4098  of the plot area (where the colored boxes, lines, and/or lines of\n\
4099  symbols are drawn) of the legend.\n\
4100 \n\
4101  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
4102  legend (PL_LEGEND_BACKGROUND).\n\
4103 \n\
4104  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
4105  for the legend (PL_LEGEND_BOUNDING_BOX).\n\
4106 \n\
4107  bb_style (PLINT, input) : The pllsty style number for the\n\
4108  bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
4109 \n\
4110  nrow (PLINT, input) : The number of rows in the matrix used to\n\
4111  render the\n\
4112  nlegend legend entries. For internal transformations of\n\
4113  nrow, see further remarks under\n\
4114  nlegend.\n\
4115 \n\
4116  ncolumn (PLINT, input) : The number of columns in the matrix used\n\
4117  to render the\n\
4118  nlegend legend entries. For internal transformations of\n\
4119  ncolumn, see further remarks under\n\
4120  nlegend.\n\
4121 \n\
4122  nlegend (PLINT, input) : Number of legend entries. The above\n\
4123  nrow and\n\
4124  ncolumn values are transformed internally to be consistent with\n\
4125  nlegend. If either\n\
4126  nrow or\n\
4127  ncolumn is non-positive it is replaced by 1. If the resulting product\n\
4128  of\n\
4129  nrow and\n\
4130  ncolumn is less than\n\
4131  nlegend, the smaller of the two (or\n\
4132  nrow, if\n\
4133  nrow ==\n\
4134  ncolumn) is increased so the product is >=\n\
4135  nlegend. Thus, for example, the common\n\
4136  nrow = 0,\n\
4137  ncolumn = 0 case is transformed internally to\n\
4138  nrow =\n\
4139  nlegend,\n\
4140  ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
4141  column.\n\
4142 \n\
4143  opt_array (PLINT_VECTOR, input) : A vector of\n\
4144  nlegend values of options to control each individual plotted area\n\
4145  corresponding to a legend entry. If the\n\
4146  PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
4147  area. If the\n\
4148  PL_LEGEND_COLOR_BOX,\n\
4149  PL_LEGEND_LINE, and/or\n\
4150  PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
4151  entry is plotted with a colored box; a line; and/or a line of\n\
4152  symbols.\n\
4153 \n\
4154  text_offset (PLFLT, input) : Offset of the text area from the plot\n\
4155  area in units of character width.\n\
4156 \n\
4157  text_scale (PLFLT, input) : Character height scale for text\n\
4158  annotations.\n\
4159 \n\
4160  text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
4161  character height from one legend entry to the next.\n\
4162 \n\
4163  text_justification (PLFLT, input) : Justification parameter used\n\
4164  for text justification. The most common values of\n\
4165  text_justification are 0., 0.5, or 1. corresponding to a text that\n\
4166  is left justified, centred, or right justified within the text\n\
4167  area, but other values are allowed as well.\n\
4168 \n\
4169  text_colors (PLINT_VECTOR, input) : A vector containing\n\
4170  nlegend cmap0 text colors.\n\
4171 \n\
4172  text (PLCHAR_MATRIX, input) : A vector of\n\
4173  nlegend UTF-8 character strings containing the legend annotations.\n\
4174 \n\
4175  box_colors (PLINT_VECTOR, input) : A vector containing\n\
4176  nlegend cmap0 colors for the discrete colored boxes (\n\
4177  PL_LEGEND_COLOR_BOX).\n\
4178 \n\
4179  box_patterns (PLINT_VECTOR, input) : A vector containing\n\
4180  nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
4181  PL_LEGEND_COLOR_BOX).\n\
4182 \n\
4183  box_scales (PLFLT_VECTOR, input) : A vector containing\n\
4184  nlegend scales (units of fraction of character height) for the height\n\
4185  of the discrete colored boxes (\n\
4186  PL_LEGEND_COLOR_BOX).\n\
4187 \n\
4188  box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4189  nlegend line widths for the patterns specified by box_patterns (\n\
4190  PL_LEGEND_COLOR_BOX).\n\
4191 \n\
4192  line_colors (PLINT_VECTOR, input) : A vector containing\n\
4193  nlegend cmap0 line colors (\n\
4194  PL_LEGEND_LINE).\n\
4195 \n\
4196  line_styles (PLINT_VECTOR, input) : A vector containing\n\
4197  nlegend line styles (plsty indices) (\n\
4198  PL_LEGEND_LINE).\n\
4199 \n\
4200  line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4201  nlegend line widths (\n\
4202  PL_LEGEND_LINE).\n\
4203 \n\
4204  symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
4205  nlegend cmap0 symbol colors (\n\
4206  PL_LEGEND_SYMBOL).\n\
4207 \n\
4208  symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
4209  nlegend scale values for the symbol height (\n\
4210  PL_LEGEND_SYMBOL).\n\
4211 \n\
4212  symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
4213  nlegend numbers of symbols to be drawn across the width of the plotted\n\
4214  area (\n\
4215  PL_LEGEND_SYMBOL).\n\
4216 \n\
4217  symbols (PLCHAR_MATRIX, input) : A vector of\n\
4218  nlegend UTF-8 character strings containing the legend symbols. (\n\
4219  PL_LEGEND_SYMBOL).\n\
4220 ";
4221 static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
4222 Set number of colors in cmap1\n\
4223 \n\
4224 DESCRIPTION:\n\
4225 \n\
4226  Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
4227  values if this is the first allocation (see the PLplot documentation).\n\
4228 \n\
4229  Redacted form: plscmap1n(ncol1)\n\
4230 \n\
4231  This function is used in examples 8, 11, 20, and 21.\n\
4232 \n\
4233 \n\
4234 \n\
4235 SYNOPSIS:\n\
4236 \n\
4237 plscmap1n(ncol1)\n\
4238 \n\
4239 ARGUMENTS:\n\
4240 \n\
4241  ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
4242  the cmap1 palette. If this number is zero or less, then the value\n\
4243  from the previous call to plscmap1n is used and if there is no\n\
4244  previous call, then a default value is used.\n\
4245 ";
4246 static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
4247 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
4248 \n\
4249 DESCRIPTION:\n\
4250 \n\
4251  Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
4252  (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
4253  Values are negative if an invalid color id is given.\n\
4254 \n\
4255  Redacted form: plgcola(r, g, b)\n\
4256 \n\
4257  This function is used in example 30.\n\
4258 \n\
4259 \n\
4260 \n\
4261 SYNOPSIS:\n\
4262 \n\
4263 plgcol0a(icol0, r, g, b, alpha)\n\
4264 \n\
4265 ARGUMENTS:\n\
4266 \n\
4267  icol0 (PLINT, input) : Index of desired cmap0 color.\n\
4268 \n\
4269  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
4270  in the range from 0 to 255.\n\
4271 \n\
4272  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
4273  in the range from 0 to 255.\n\
4274 \n\
4275  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
4276  in the range from 0 to 255.\n\
4277 \n\
4278  alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
4279  transparency in the range from (0.0-1.0).\n\
4280 ";
4281 static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
4282 Replays contents of plot buffer to current device/file\n\
4283 \n\
4284 DESCRIPTION:\n\
4285 \n\
4286  Replays contents of plot buffer to current device/file.\n\
4287 \n\
4288  Redacted form: plreplot()\n\
4289 \n\
4290  This function is used in example 1,20.\n\
4291 \n\
4292 \n\
4293 \n\
4294 SYNOPSIS:\n\
4295 \n\
4296 plreplot()\n\
4297 ";
4298 static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
4299 Simple routine to write labels\n\
4300 \n\
4301 DESCRIPTION:\n\
4302 \n\
4303  Routine for writing simple labels. Use plmtex for more complex labels.\n\
4304 \n\
4305  Redacted form: pllab(xlabel, ylabel, tlabel)\n\
4306 \n\
4307  This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
4308 \n\
4309 \n\
4310 \n\
4311 SYNOPSIS:\n\
4312 \n\
4313 pllab(xlabel, ylabel, tlabel)\n\
4314 \n\
4315 ARGUMENTS:\n\
4316 \n\
4317  xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4318  the label for the x axis.\n\
4319 \n\
4320  ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4321  the label for the y axis.\n\
4322 \n\
4323  tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4324  the title of the plot.\n\
4325 ";
4326 static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
4327 Set parameters that define current device-space window\n\
4328 \n\
4329 DESCRIPTION:\n\
4330 \n\
4331  Set relative margin width, aspect ratio, and relative justification\n\
4332  that define current device-space window. If you want to just use the\n\
4333  previous value for any of these, just pass in the magic value\n\
4334  PL_NOTSET. It is unlikely that one should ever need to change the\n\
4335  aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4336  called the default values of mar, jx, and jy are all 0. aspect is set\n\
4337  to a device-specific value.\n\
4338 \n\
4339  Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4340 \n\
4341  This function is used in example 31.\n\
4342 \n\
4343 \n\
4344 \n\
4345 SYNOPSIS:\n\
4346 \n\
4347 plsdidev(mar, aspect, jx, jy)\n\
4348 \n\
4349 ARGUMENTS:\n\
4350 \n\
4351  mar (PLFLT, input) : Relative margin width.\n\
4352 \n\
4353  aspect (PLFLT, input) : Aspect ratio.\n\
4354 \n\
4355  jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4356  the range -0.5 to 0.5.\n\
4357 \n\
4358  jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4359  the range -0.5 to 0.5.\n\
4360 ";
4361 static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
4362 Begin a new page\n\
4363 \n\
4364 DESCRIPTION:\n\
4365 \n\
4366  Begins a new page. For a file driver, the output file is opened if\n\
4367  necessary. Advancing the page via pleop and plbop is useful when a\n\
4368  page break is desired at a particular point when plotting to subpages.\n\
4369  Another use for pleop and plbop is when plotting pages to different\n\
4370  files, since you can manually set the file name by calling plsfnam\n\
4371  after the call to pleop. (In fact some drivers may only support a\n\
4372  single page per file, making this a necessity.) One way to handle\n\
4373  this case automatically is to page advance via pladv, but enable\n\
4374  familying (see plsfam) with a small limit on the file size so that a\n\
4375  new family member file will be created on each page break.\n\
4376 \n\
4377  Redacted form: plbop()\n\
4378 \n\
4379  This function is used in examples 2 and 20.\n\
4380 \n\
4381 \n\
4382 \n\
4383 SYNOPSIS:\n\
4384 \n\
4385 plbop()\n\
4386 ";
4387 static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
4388 Set cmap0 colors by 8-bit RGB values\n\
4389 \n\
4390 DESCRIPTION:\n\
4391 \n\
4392  Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4393  documentation). This sets the entire color map -- only as many colors\n\
4394  as specified will be allocated.\n\
4395 \n\
4396  Redacted form: plscmap0(r, g, b)\n\
4397 \n\
4398  This function is used in examples 2 and 24.\n\
4399 \n\
4400 \n\
4401 \n\
4402 SYNOPSIS:\n\
4403 \n\
4404 plscmap0(r, g, b, ncol0)\n\
4405 \n\
4406 ARGUMENTS:\n\
4407 \n\
4408  r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4409  integers (0-255) representing the degree of red in the color.\n\
4410 \n\
4411  g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4412  integers (0-255) representing the degree of green in the color.\n\
4413 \n\
4414  b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4415  integers (0-255) representing the degree of blue in the color.\n\
4416 \n\
4417  ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4418 ";
4419 static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
4420 Set the number of subpages in x and y\n\
4421 \n\
4422 DESCRIPTION:\n\
4423 \n\
4424  Set the number of subpages in x and y.\n\
4425 \n\
4426  Redacted form: plssub(nx, ny)\n\
4427 \n\
4428  This function is examples 1,2,14,21,25,27.\n\
4429 \n\
4430 \n\
4431 \n\
4432 SYNOPSIS:\n\
4433 \n\
4434 plssub(nx, ny)\n\
4435 \n\
4436 ARGUMENTS:\n\
4437 \n\
4438  nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4439  of window columns).\n\
4440 \n\
4441  ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4442  of window rows).\n\
4443 ";
4444 static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
4445 Set a global coordinate transform function\n\
4446 \n\
4447 DESCRIPTION:\n\
4448 \n\
4449  This function can be used to define a coordinate transformation which\n\
4450  affects all elements drawn within the current plot window. The\n\
4451  coordinate_transform callback function is similar to that provided for\n\
4452  the plmap and plmeridians functions. The coordinate_transform_data\n\
4453  parameter may be used to pass extra data to coordinate_transform.\n\
4454 \n\
4455  Redacted form: General: plstransform(coordinate_transform,\n\
4456  coordinate_transform_data)\n\
4457 \n\
4458 \n\
4459  This function is used in examples 19 and 22.\n\
4460 \n\
4461 \n\
4462 \n\
4463 SYNOPSIS:\n\
4464 \n\
4465 plstransform(coordinate_transform, coordinate_transform_data)\n\
4466 \n\
4467 ARGUMENTS:\n\
4468 \n\
4469  coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4470  function that defines the transformation from the input (x, y)\n\
4471  world coordinates to new PLplot world coordinates. If\n\
4472  coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4473  case), then no transform is applied.\n\
4474 \n\
4475  coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4476  for\n\
4477  coordinate_transform.\n\
4478 ";
4479 static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
4480 Set opaque RGB cmap1 colors values\n\
4481 \n\
4482 DESCRIPTION:\n\
4483 \n\
4484  Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4485  vector values. This function also sets the number of cmap1 colors.\n\
4486  N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4487  in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4488  plcol1) to an integer index of these RGB vectors in the range from 0\n\
4489  to\n\
4490  ncol1-1. So in order for this continuous color model to work\n\
4491  properly, it is the responsibility of the user of plscmap1 to insure\n\
4492  that these RGB vectors are continuous functions of their integer\n\
4493  indices.\n\
4494 \n\
4495  Redacted form: plscmap1(r, g, b)\n\
4496 \n\
4497  This function is used in example 31.\n\
4498 \n\
4499 \n\
4500 \n\
4501 SYNOPSIS:\n\
4502 \n\
4503 plscmap1(r, g, b, ncol1)\n\
4504 \n\
4505 ARGUMENTS:\n\
4506 \n\
4507  r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4508  8-bit integers in the range from 0-255) the degree of red in the\n\
4509  color as a continuous function of the integer index of the vector.\n\
4510 \n\
4511  g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4512  8-bit integers in the range from 0-255) the degree of green in the\n\
4513  color as a continuous function of the integer index of the vector.\n\
4514 \n\
4515  b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4516  8-bit integers in the range from 0-255) the degree of blue in the\n\
4517  color as a continuous function of the integer index of the vector.\n\
4518 \n\
4519  ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4520 ";
4521 static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
4522 Configure the transformation between continuous and broken-down time for the current stream\n\
4523 \n\
4524 DESCRIPTION:\n\
4525 \n\
4526  Configure the transformation between continuous and broken-down time\n\
4527  for the current stream. This transformation is used by both plbtime\n\
4528  and plctime.\n\
4529 \n\
4530  Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4531  ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4532 \n\
4533 \n\
4534  This function is used in example 29.\n\
4535 \n\
4536 \n\
4537 \n\
4538 SYNOPSIS:\n\
4539 \n\
4540 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4541 \n\
4542 ARGUMENTS:\n\
4543 \n\
4544  scale (PLFLT, input) : The number of days per continuous time unit.\n\
4545  As a special case, if\n\
4546  scale is 0., then all other arguments are ignored, and the result (the\n\
4547  default used by PLplot) is the equivalent of a call to\n\
4548  plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4549  That is, for this special case broken-down time is calculated with\n\
4550  the proleptic Gregorian calendar with no leap seconds inserted,\n\
4551  and the continuous time is defined as the number of seconds since\n\
4552  the Unix epoch of 1970-01-01T00:00:00Z.\n\
4553 \n\
4554  offset1 (PLFLT, input) : If\n\
4555  ifbtime_offset is true, the parameters\n\
4556  offset1 and\n\
4557  offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4558  (with units in days) specify the epoch of the continuous time\n\
4559  relative to the MJD epoch corresponding to the Gregorian calendar\n\
4560  date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4561  are used to specify the origin to allow users (by specifying\n\
4562  offset1 as an integer that can be exactly represented by a\n\
4563  floating-point variable and specifying\n\
4564  offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4565  the numerical errors of the continuous time representation.\n\
4566 \n\
4567  offset2 (PLFLT, input) : See documentation of\n\
4568  offset1.\n\
4569 \n\
4570  ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4571  transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4572  calendar is used for broken-down time rather than the proleptic\n\
4573  Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4574  have been historically used to define UTC are inserted into the\n\
4575  broken-down time. Other possibilities for additional control bits\n\
4576  for ccontrol exist such as making the historical time corrections\n\
4577  in the broken-down time corresponding to ET (ephemeris time) or\n\
4578  making the (slightly non-constant) corrections from international\n\
4579  atomic time (TAI) to what astronomers define as terrestrial time\n\
4580  (TT). But those additional possibilities have not been\n\
4581  implemented yet in the qsastime library (one of the PLplot utility\n\
4582  libraries).\n\
4583 \n\
4584  ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4585  epoch of the continuous time scale is specified by the user. If\n\
4586  ifbtime_offset is false, then\n\
4587  offset1 and\n\
4588  offset2 are used to specify the epoch, and the following broken-down\n\
4589  time parameters are completely ignored. If\n\
4590  ifbtime_offset is true, then\n\
4591  offset1 and\n\
4592  offset2 are completely ignored, and the following broken-down time\n\
4593  parameters are used to specify the epoch.\n\
4594 \n\
4595  year (PLINT, input) : Year of epoch.\n\
4596 \n\
4597  month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4598  11 (December).\n\
4599 \n\
4600  day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4601 \n\
4602  hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4603 \n\
4604  min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4605 \n\
4606  sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4607 ";
4608 static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
4609 Set length of minor ticks\n\
4610 \n\
4611 DESCRIPTION:\n\
4612 \n\
4613  This sets up the length of the minor ticks and the length of the\n\
4614  terminals on error bars. The actual length is the product of the\n\
4615  default length and a scaling factor as for character height.\n\
4616 \n\
4617  Redacted form: plsmin(def, scale)\n\
4618 \n\
4619  This function is used in example 29.\n\
4620 \n\
4621 \n\
4622 \n\
4623 SYNOPSIS:\n\
4624 \n\
4625 plsmin(def, scale)\n\
4626 \n\
4627 ARGUMENTS:\n\
4628 \n\
4629  def (PLFLT, input) : The default length of a minor tick in\n\
4630  millimeters, should be set to zero if the default length is to\n\
4631  remain unchanged.\n\
4632 \n\
4633  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4634  actual tick length.\n\
4635 ";
4636 static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
4637 Set character size\n\
4638 \n\
4639 DESCRIPTION:\n\
4640 \n\
4641  This sets up the size of all subsequent characters drawn. The actual\n\
4642  height of a character is the product of the default character size and\n\
4643  a scaling factor.\n\
4644 \n\
4645  Redacted form: plschr(def, scale)\n\
4646 \n\
4647  This function is used in examples 2, 13, 23, and 24.\n\
4648 \n\
4649 \n\
4650 \n\
4651 SYNOPSIS:\n\
4652 \n\
4653 plschr(def, scale)\n\
4654 \n\
4655 ARGUMENTS:\n\
4656 \n\
4657  def (PLFLT, input) : The default height of a character in\n\
4658  millimeters, should be set to zero if the default height is to\n\
4659  remain unchanged. For rasterized drivers the dx and dy values\n\
4660  specified in plspage are used to convert from mm to pixels (note\n\
4661  the different unit systems used). This dpi aware scaling is not\n\
4662  implemented for all drivers yet.\n\
4663 \n\
4664  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4665  actual character height.\n\
4666 ";
4667 static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4668 Initialize PLplot\n\
4669 \n\
4670 DESCRIPTION:\n\
4671 \n\
4672  Initializing the plotting package. The program prompts for the device\n\
4673  keyword or number of the desired output device. Hitting a RETURN in\n\
4674  response to the prompt is the same as selecting the first device.\n\
4675  plinit will issue no prompt if either the device was specified\n\
4676  previously (via command line flag, the plsetopt function, or the\n\
4677  plsdev function), or if only one device is enabled when PLplot is\n\
4678  installed. If subpages have been specified, the output device is\n\
4679  divided into nx by ny subpages, each of which may be used\n\
4680  independently. If plinit is called again during a program, the\n\
4681  previously opened file will be closed. The subroutine pladv is used\n\
4682  to advance from one subpage to the next.\n\
4683 \n\
4684  Redacted form: plinit()\n\
4685 \n\
4686  This function is used in all of the examples.\n\
4687 \n\
4688 \n\
4689 \n\
4690 SYNOPSIS:\n\
4691 \n\
4692 plinit()\n\
4693 ";
4694 static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4695 Draw a box with axes, etc\n\
4696 \n\
4697 DESCRIPTION:\n\
4698 \n\
4699  Draws a box around the currently defined viewport, and labels it with\n\
4700  world coordinate values appropriate to the window. Thus plbox should\n\
4701  only be called after defining both viewport and window. The ascii\n\
4702  character strings xopt and yopt specify how the box should be drawn as\n\
4703  described below. If ticks and/or subticks are to be drawn for a\n\
4704  particular axis, the tick intervals and number of subintervals may be\n\
4705  specified explicitly, or they may be defaulted by setting the\n\
4706  appropriate arguments to zero.\n\
4707 \n\
4708  Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4709 \n\
4710 \n\
4711  This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4712  and 29.\n\
4713 \n\
4714 \n\
4715 \n\
4716 SYNOPSIS:\n\
4717 \n\
4718 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4719 \n\
4720 ARGUMENTS:\n\
4721 \n\
4722  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4723  options for the x axis. The string can include any combination of\n\
4724  the following letters (upper or lower case) in any order: a: Draws\n\
4725  axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4726  (x=0).\n\
4727  b: Draws bottom (X) or left (Y) edge of frame.\n\
4728  c: Draws top (X) or right (Y) edge of frame.\n\
4729  d: Plot labels as date / time. Values are assumed to be\n\
4730  seconds since the epoch (as used by gmtime).\n\
4731  f: Always use fixed point numeric labels.\n\
4732  g: Draws a grid at the major tick interval.\n\
4733  h: Draws a grid at the minor tick interval.\n\
4734  i: Inverts tick marks, so they are drawn outwards, rather than\n\
4735  inwards.\n\
4736  l: Labels axis logarithmically. This only affects the labels,\n\
4737  not the data, and so it is necessary to compute the logarithms\n\
4738  of data points before passing them to any of the drawing\n\
4739  routines.\n\
4740  m: Writes numeric labels at major tick intervals in the\n\
4741  unconventional location (above box for X, right of box for Y).\n\
4742  n: Writes numeric labels at major tick intervals in the\n\
4743  conventional location (below box for X, left of box for Y).\n\
4744  o: Use custom labelling function to generate axis label text.\n\
4745  The custom labelling function can be defined with the\n\
4746  plslabelfunc command.\n\
4747  s: Enables subticks between major ticks, only valid if t is\n\
4748  also specified.\n\
4749  t: Draws major ticks.\n\
4750  u: Exactly like \"b\" except don\'t draw edge line.\n\
4751  w: Exactly like \"c\" except don\'t draw edge line.\n\
4752  x: Exactly like \"t\" (including the side effect of the\n\
4753  numerical labels for the major ticks) except exclude drawing\n\
4754  the major and minor tick marks.\n\
4755 \n\
4756 \n\
4757  xtick (PLFLT, input) : World coordinate interval between major\n\
4758  ticks on the x axis. If it is set to zero, PLplot automatically\n\
4759  generates a suitable tick interval.\n\
4760 \n\
4761  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4762  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4763  generates a suitable minor tick interval.\n\
4764 \n\
4765  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4766  options for the y axis. The string can include any combination of\n\
4767  the letters defined above for xopt, and in addition may contain:\n\
4768  v: Write numeric labels for the y axis parallel to the base of the\n\
4769  graph, rather than parallel to the axis.\n\
4770 \n\
4771 \n\
4772  ytick (PLFLT, input) : World coordinate interval between major\n\
4773  ticks on the y axis. If it is set to zero, PLplot automatically\n\
4774  generates a suitable tick interval.\n\
4775 \n\
4776  nysub (PLINT, input) : Number of subintervals between major y axis\n\
4777  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4778  generates a suitable minor tick interval.\n\
4779 ";
4780 static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4781 Get parameters that define current device-space window\n\
4782 \n\
4783 DESCRIPTION:\n\
4784 \n\
4785  Get relative margin width, aspect ratio, and relative justification\n\
4786  that define current device-space window. If plsdidev has not been\n\
4787  called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4788  p_jy will all be 0.\n\
4789 \n\
4790  Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4791 \n\
4792  This function is used in example 31.\n\
4793 \n\
4794 \n\
4795 \n\
4796 SYNOPSIS:\n\
4797 \n\
4798 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4799 \n\
4800 ARGUMENTS:\n\
4801 \n\
4802  p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4803  margin width.\n\
4804 \n\
4805  p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4806  ratio.\n\
4807 \n\
4808  p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4809  justification in x.\n\
4810 \n\
4811  p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4812  justification in y.\n\
4813 ";
4814 static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4815 Plot a glyph at the specified points\n\
4816 \n\
4817 DESCRIPTION:\n\
4818 \n\
4819  Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4820  because many[!] more glyphs are accessible with plstring.) The glyph\n\
4821  is specified with a PLplot user string. Note that the user string is\n\
4822  not actually limited to one glyph so it is possible (but not normally\n\
4823  useful) to plot more than one glyph at the specified points with this\n\
4824  function. As with plmtex and plptex, the user string can contain FCI\n\
4825  escapes to determine the font, UTF-8 code to determine the glyph or\n\
4826  else PLplot escapes for Hershey or unicode text to determine the\n\
4827  glyph.\n\
4828 \n\
4829  Redacted form: plstring(x, y, string)\n\
4830 \n\
4831  This function is used in examples 4, 21 and 26.\n\
4832 \n\
4833 \n\
4834 \n\
4835 SYNOPSIS:\n\
4836 \n\
4837 plstring(n, x, y, string)\n\
4838 \n\
4839 ARGUMENTS:\n\
4840 \n\
4841  n (PLINT, input) : Number of points in the x and y vectors.\n\
4842 \n\
4843  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4844  the points.\n\
4845 \n\
4846  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4847  the points.\n\
4848 \n\
4849  string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4850  the glyph(s) to be plotted at each of the n points.\n\
4851 ";
4852 static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
4853 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4854 \n\
4855 DESCRIPTION:\n\
4856 \n\
4857  As per plmapline, however the items are plotted as strings or points\n\
4858  in the same way as plstring.\n\
4859 \n\
4860  Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4861  maxy, plotentries)\n\
4862 \n\
4863  This function is not used in any examples.\n\
4864 \n\
4865 \n\
4866 \n\
4867 SYNOPSIS:\n\
4868 \n\
4869 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4870 \n\
4871 ARGUMENTS:\n\
4872 \n\
4873  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4874  transform the coordinates given in the shapefile into a plot\n\
4875  coordinate system. By using this transform, we can change from a\n\
4876  longitude, latitude coordinate to a polar stereographic project,\n\
4877  for example. Initially, x[0]..[n-1] are the longitudes and\n\
4878  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4879  mapform(), x[] and y[] should be replaced by the corresponding\n\
4880  plot coordinates. If no transform is desired, mapform can be\n\
4881  replaced by NULL.\n\
4882 \n\
4883  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4884  the file name of a set of Shapefile files without the file\n\
4885  extension.\n\
4886 \n\
4887  string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
4888  drawn.\n\
4889 \n\
4890  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
4891  be in the same units as used by the Shapefile. You could use a\n\
4892  very large negative number to plot everything, but you can improve\n\
4893  performance by limiting the area drawn. The units must match those\n\
4894  of the Shapefile projection, which may be for example longitude or\n\
4895  distance. The value of minx must be less than the value of maxx.\n\
4896 \n\
4897  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
4898  use a very large number to plot everything, but you can improve\n\
4899  performance by limiting the area drawn.\n\
4900 \n\
4901  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
4902  be in the same units as used by the Shapefile. You could use a\n\
4903  very large negative number to plot everything, but you can improve\n\
4904  performance by limiting the area drawn. The units must match those\n\
4905  of the Shapefile projection, which may be for example latitude or\n\
4906  distance. The value of miny must be less than the value of maxy.\n\
4907 \n\
4908  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
4909  use a very large number to plot everything, but you can improve\n\
4910  performance by limiting the area drawn.\n\
4911 \n\
4912  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
4913  zero-based indices of the Shapefile elements which will be drawn.\n\
4914  Setting\n\
4915  plotentries to NULL will plot all elements of the Shapefile.\n\
4916 \n\
4917  nplotentries (PLINT, input) : The number of items in\n\
4918  plotentries. Ignored if\n\
4919  plotentries is NULL.\n\
4920 ";
4921 static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
4922 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
4923 \n\
4924 DESCRIPTION:\n\
4925 \n\
4926  Sets up plotter environment for simple graphs by calling pladv and\n\
4927  setting up viewport and window to sensible default values. plenv0\n\
4928  leaves a standard margin (left-hand margin of eight character heights,\n\
4929  and a margin around the other three sides of five character heights)\n\
4930  around most graphs for axis labels and a title. When these defaults\n\
4931  are not suitable, use the individual routines plvpas, plvpor, or\n\
4932  plvasp for setting up the viewport, plwind for defining the window,\n\
4933  and plbox for drawing the box.\n\
4934 \n\
4935  Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4936 \n\
4937  This function is used in example 21.\n\
4938 \n\
4939 \n\
4940 \n\
4941 SYNOPSIS:\n\
4942 \n\
4943 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4944 \n\
4945 ARGUMENTS:\n\
4946 \n\
4947  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4948  world coordinates).\n\
4949 \n\
4950  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4951  world coordinates).\n\
4952 \n\
4953  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4954  coordinates).\n\
4955 \n\
4956  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4957  coordinates).\n\
4958 \n\
4959  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4960  scales will not be set, the user must set up the scale before\n\
4961  calling plenv0 using plsvpa, plvasp or other.\n\
4962  0: the x and y axes are scaled independently to use as much of\n\
4963  the screen as possible.\n\
4964  1: the scales of the x and y axes are made equal.\n\
4965  2: the axis of the x and y axes are made equal, and the plot\n\
4966  box will be square.\n\
4967 \n\
4968 \n\
4969  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4970  -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
4971  -1: draw box only.\n\
4972  0: draw box, ticks, and numeric tick labels.\n\
4973  1: also draw coordinate axes at x=0 and y=0.\n\
4974  2: also draw a grid at major tick positions in both\n\
4975  coordinates.\n\
4976  3: also draw a grid at minor tick positions in both\n\
4977  coordinates.\n\
4978  10: same as 0 except logarithmic x tick marks. (The x data\n\
4979  have to be converted to logarithms separately.)\n\
4980  11: same as 1 except logarithmic x tick marks. (The x data\n\
4981  have to be converted to logarithms separately.)\n\
4982  12: same as 2 except logarithmic x tick marks. (The x data\n\
4983  have to be converted to logarithms separately.)\n\
4984  13: same as 3 except logarithmic x tick marks. (The x data\n\
4985  have to be converted to logarithms separately.)\n\
4986  20: same as 0 except logarithmic y tick marks. (The y data\n\
4987  have to be converted to logarithms separately.)\n\
4988  21: same as 1 except logarithmic y tick marks. (The y data\n\
4989  have to be converted to logarithms separately.)\n\
4990  22: same as 2 except logarithmic y tick marks. (The y data\n\
4991  have to be converted to logarithms separately.)\n\
4992  23: same as 3 except logarithmic y tick marks. (The y data\n\
4993  have to be converted to logarithms separately.)\n\
4994  30: same as 0 except logarithmic x and y tick marks. (The x\n\
4995  and y data have to be converted to logarithms separately.)\n\
4996  31: same as 1 except logarithmic x and y tick marks. (The x\n\
4997  and y data have to be converted to logarithms separately.)\n\
4998  32: same as 2 except logarithmic x and y tick marks. (The x\n\
4999  and y data have to be converted to logarithms separately.)\n\
5000  33: same as 3 except logarithmic x and y tick marks. (The x\n\
5001  and y data have to be converted to logarithms separately.)\n\
5002  40: same as 0 except date / time x labels.\n\
5003  41: same as 1 except date / time x labels.\n\
5004  42: same as 2 except date / time x labels.\n\
5005  43: same as 3 except date / time x labels.\n\
5006  50: same as 0 except date / time y labels.\n\
5007  51: same as 1 except date / time y labels.\n\
5008  52: same as 2 except date / time y labels.\n\
5009  53: same as 3 except date / time y labels.\n\
5010  60: same as 0 except date / time x and y labels.\n\
5011  61: same as 1 except date / time x and y labels.\n\
5012  62: same as 2 except date / time x and y labels.\n\
5013  63: same as 3 except date / time x and y labels.\n\
5014  70: same as 0 except custom x and y labels.\n\
5015  71: same as 1 except custom x and y labels.\n\
5016  72: same as 2 except custom x and y labels.\n\
5017  73: same as 3 except custom x and y labels.\n\
5018 ";
5019 static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
5020 Configure the transformations required for projecting a 3D surface on a 2D window\n\
5021 \n\
5022 DESCRIPTION:\n\
5023 \n\
5024  Configure the transformations required for projecting a 3D surface on\n\
5025  an existing 2D window. Those transformations (see the PLplot\n\
5026  documentation) are done to a rectangular cuboid enclosing the 3D\n\
5027  surface which has its limits expressed in 3D world coordinates and\n\
5028  also normalized 3D coordinates (used for interpreting the altitude and\n\
5029  azimuth of the viewing angle). The transformations consist of the\n\
5030  linear transform from 3D world coordinates to normalized 3D\n\
5031  coordinates, and the 3D rotation of normalized coordinates required to\n\
5032  align the pole of the new 3D coordinate system with the viewing\n\
5033  direction specified by altitude and azimuth so that x and y of the\n\
5034  surface elements in that transformed coordinate system are the\n\
5035  projection of the 3D surface with given viewing direction on the 2D\n\
5036  window.\n\
5037 \n\
5038  The enclosing rectangular cuboid for the surface plot is defined by\n\
5039  xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
5040  mapped into the same rectangular cuboid with normalized 3D coordinate\n\
5041  sizes of basex by basey by height so that xmin maps to -\n\
5042  basex/2, xmax maps to basex/2, ymin maps to -\n\
5043  basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
5044  The resulting rectangular cuboid in normalized coordinates is then\n\
5045  viewed by an observer at altitude alt and azimuth az. This routine\n\
5046  must be called before plbox3 or any of the 3D surface plotting\n\
5047  routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
5048  plsurf3dl or plfill3.\n\
5049 \n\
5050  Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
5051  zmin, zmax, alt, az)\n\
5052 \n\
5053  This function is examples 8, 11, 18, and 21.\n\
5054 \n\
5055 \n\
5056 \n\
5057 SYNOPSIS:\n\
5058 \n\
5059 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
5060 \n\
5061 ARGUMENTS:\n\
5062 \n\
5063  basex (PLFLT, input) : The normalized x coordinate size of the\n\
5064  rectangular cuboid.\n\
5065 \n\
5066  basey (PLFLT, input) : The normalized y coordinate size of the\n\
5067  rectangular cuboid.\n\
5068 \n\
5069  height (PLFLT, input) : The normalized z coordinate size of the\n\
5070  rectangular cuboid.\n\
5071 \n\
5072  xmin (PLFLT, input) : The minimum x world coordinate of the\n\
5073  rectangular cuboid.\n\
5074 \n\
5075  xmax (PLFLT, input) : The maximum x world coordinate of the\n\
5076  rectangular cuboid.\n\
5077 \n\
5078  ymin (PLFLT, input) : The minimum y world coordinate of the\n\
5079  rectangular cuboid.\n\
5080 \n\
5081  ymax (PLFLT, input) : The maximum y world coordinate of the\n\
5082  rectangular cuboid.\n\
5083 \n\
5084  zmin (PLFLT, input) : The minimum z world coordinate of the\n\
5085  rectangular cuboid.\n\
5086 \n\
5087  zmax (PLFLT, input) : The maximum z world coordinate of the\n\
5088  rectangular cuboid.\n\
5089 \n\
5090  alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
5091  plane of the rectangular cuboid in normalized coordinates.\n\
5092 \n\
5093  az (PLFLT, input) : The viewing azimuth in degrees of the\n\
5094  rectangular cuboid in normalized coordinates. When az=0, the\n\
5095  observer is looking face onto the zx plane of the rectangular\n\
5096  cuboid in normalized coordinates, and as az is increased, the\n\
5097  observer moves clockwise around that cuboid when viewed from above\n\
5098  the xy plane.\n\
5099 ";
5100 static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
5101 Draw filled polygon\n\
5102 \n\
5103 DESCRIPTION:\n\
5104 \n\
5105  Fills the polygon defined by the n points (\n\
5106  x[i],\n\
5107  y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
5108  style is a solid fill. The routine will automatically close the\n\
5109  polygon between the last and first vertices. If multiple closed\n\
5110  polygons are passed in x and y then plfill will fill in between them.\n\
5111 \n\
5112  Redacted form: plfill(x,y)\n\
5113 \n\
5114  This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
5115 \n\
5116 \n\
5117 \n\
5118 SYNOPSIS:\n\
5119 \n\
5120 plfill(n, x, y)\n\
5121 \n\
5122 ARGUMENTS:\n\
5123 \n\
5124  n (PLINT, input) : Number of vertices in polygon.\n\
5125 \n\
5126  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5127  vertices.\n\
5128 \n\
5129  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5130  vertices.\n\
5131 ";
5132 static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
5133 Magnitude colored plot surface with contour\n\
5134 \n\
5135 DESCRIPTION:\n\
5136 \n\
5137  Aside from dropping the\n\
5138  side functionality this is a more powerful form of plot3d: the surface\n\
5139  mesh can be colored accordingly to the current z value being plotted,\n\
5140  a contour plot can be drawn at the base XY plane, and a curtain can be\n\
5141  drawn between the plotted function border and the base XY plane. The\n\
5142  arguments are identical to those of plmeshc. The only difference\n\
5143  between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
5144  the surface, while plot3dc only draws the surface as viewed from the\n\
5145  top.\n\
5146 \n\
5147  Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
5148 \n\
5149 \n\
5150  This function is used in example 21.\n\
5151 \n\
5152 \n\
5153 \n\
5154 SYNOPSIS:\n\
5155 \n\
5156 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
5157 \n\
5158 ARGUMENTS:\n\
5159 \n\
5160  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5161  which the function is evaluated.\n\
5162 \n\
5163  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5164  which the function is evaluated.\n\
5165 \n\
5166  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5167  plot. Should have dimensions of\n\
5168  nx by\n\
5169  ny.\n\
5170 \n\
5171  nx (PLINT, input) : Number of x values at which function is\n\
5172  evaluated.\n\
5173 \n\
5174  ny (PLINT, input) : Number of y values at which function is\n\
5175  evaluated.\n\
5176 \n\
5177  opt (PLINT, input) : Determines the way in which the surface is\n\
5178  represented. To specify more than one option just add the options,\n\
5179  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
5180  showing z as a function of x for each value of y[j] .\n\
5181  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5182  for each value of x[i] .\n\
5183  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5184  at which function is defined.\n\
5185  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
5186  the z value being plotted. The color is used from the current\n\
5187  cmap1.\n\
5188  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5189  using parameters\n\
5190  nlevel and\n\
5191  clevel.\n\
5192  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5193  the borders of the plotted function.\n\
5194 \n\
5195 \n\
5196  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5197  levels.\n\
5198 \n\
5199  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5200 ";
5201 static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
5202 Write text relative to viewport boundaries\n\
5203 \n\
5204 DESCRIPTION:\n\
5205 \n\
5206  Writes text at a specified position relative to the viewport\n\
5207  boundaries. Text may be written inside or outside the viewport, but\n\
5208  is clipped at the subpage boundaries. The reference point of a string\n\
5209  lies along a line passing through the string at half the height of a\n\
5210  capital letter. The position of the reference point along this line\n\
5211  is determined by just, and the position of the reference point\n\
5212  relative to the viewport is set by disp and pos.\n\
5213 \n\
5214  Redacted form: General: plmtex(side, disp, pos, just, text)\n\
5215 \n\
5216 \n\
5217  This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
5218  26.\n\
5219 \n\
5220 \n\
5221 \n\
5222 SYNOPSIS:\n\
5223 \n\
5224 plmtex(side, disp, pos, just, text)\n\
5225 \n\
5226 ARGUMENTS:\n\
5227 \n\
5228  side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5229  the side of the viewport along which the text is to be written.\n\
5230  The string must be one of: b: Bottom of viewport, text written\n\
5231  parallel to edge.\n\
5232  bv: Bottom of viewport, text written at right angles to edge.\n\
5233  l: Left of viewport, text written parallel to edge.\n\
5234  lv: Left of viewport, text written at right angles to edge.\n\
5235  r: Right of viewport, text written parallel to edge.\n\
5236  rv: Right of viewport, text written at right angles to edge.\n\
5237  t: Top of viewport, text written parallel to edge.\n\
5238  tv: Top of viewport, text written at right angles to edge.\n\
5239 \n\
5240 \n\
5241  disp (PLFLT, input) : Position of the reference point of string,\n\
5242  measured outwards from the specified viewport edge in units of the\n\
5243  current character height. Use negative disp to write within the\n\
5244  viewport.\n\
5245 \n\
5246  pos (PLFLT, input) : Position of the reference point of string\n\
5247  along the specified edge, expressed as a fraction of the length of\n\
5248  the edge.\n\
5249 \n\
5250  just (PLFLT, input) : Specifies the position of the string relative\n\
5251  to its reference point. If just=0. , the reference point is at\n\
5252  the left and if just=1. , it is at the right of the string. Other\n\
5253  values of just give intermediate justifications.\n\
5254 \n\
5255  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5256  written out.\n\
5257 ";
5258 static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
5259 Set arrow style for vector plots\n\
5260 \n\
5261 DESCRIPTION:\n\
5262 \n\
5263  Set the style for the arrow used by plvect to plot vectors.\n\
5264 \n\
5265  Redacted form: plsvect(arrowx, arrowy, fill)\n\
5266 \n\
5267  This function is used in example 22.\n\
5268 \n\
5269 \n\
5270 \n\
5271 SYNOPSIS:\n\
5272 \n\
5273 plsvect(arrowx, arrowy, npts, fill)\n\
5274 \n\
5275 ARGUMENTS:\n\
5276 \n\
5277  arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
5278  the x and y points which make up the arrow. The arrow is plotted\n\
5279  by joining these points to form a polygon. The scaling assumes\n\
5280  that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
5281  <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
5282  will be reset to its default.\n\
5283 \n\
5284  npts (PLINT, input) : Number of points in the vectors arrowx and\n\
5285  arrowy.\n\
5286 \n\
5287  fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
5288  fill is false then the arrow is open.\n\
5289 ";
5290 static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5291 Get family file parameters\n\
5292 \n\
5293 DESCRIPTION:\n\
5294 \n\
5295  Gets information about current family file, if familying is enabled.\n\
5296  See the PLplot documentation for more information.\n\
5297 \n\
5298  Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5299 \n\
5300  This function is used in examples 14 and 31.\n\
5301 \n\
5302 \n\
5303 \n\
5304 SYNOPSIS:\n\
5305 \n\
5306 plgfam(p_fam, p_num, p_bmax)\n\
5307 \n\
5308 ARGUMENTS:\n\
5309 \n\
5310  p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5311  family flag value. If nonzero, familying is enabled for the\n\
5312  current device.\n\
5313 \n\
5314  p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5315  family file number.\n\
5316 \n\
5317  p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5318  file size (in bytes) for a family file.\n\
5319 ";
5320 static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
5321 Random number generator returning a real random number in the range [0,1]\n\
5322 \n\
5323 DESCRIPTION:\n\
5324 \n\
5325  Random number generator returning a real random number in the range\n\
5326  [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5327  / compilers provide their own random number generator, and so this is\n\
5328  provided purely for convenience and to give a consistent random number\n\
5329  generator across all languages supported by PLplot. This is\n\
5330  particularly useful for comparing results from the test suite of\n\
5331  examples.\n\
5332 \n\
5333  Redacted form: plrandd()\n\
5334 \n\
5335  This function is used in examples 17 and 21.\n\
5336 \n\
5337 \n\
5338 \n\
5339 SYNOPSIS:\n\
5340 \n\
5341 plrandd()\n\
5342 ";
5343 static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5344 Contour plot\n\
5345 \n\
5346 DESCRIPTION:\n\
5347 \n\
5348  Draws a contour plot of the data in f[\n\
5349  nx][\n\
5350  ny], using the nlevel contour levels specified by clevel. Only the\n\
5351  region of the matrix from kx to lx and from ky to ly is plotted out\n\
5352  where all these index ranges are interpreted as one-based for\n\
5353  historical reasons. A transformation routine pointed to by pltr with\n\
5354  a generic pointer pltr_data for additional data required by the\n\
5355  transformation routine is used to map indices within the matrix to the\n\
5356  world coordinates.\n\
5357 \n\
5358  Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5359  where (see above discussion) the pltr, pltr_data callback arguments\n\
5360  are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5361  vectors; or xg and yg matrices.\n\
5362 \n\
5363  This function is used in examples 9, 14, 16, and 22.\n\
5364 \n\
5365 \n\
5366 \n\
5367 SYNOPSIS:\n\
5368 \n\
5369 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5370 \n\
5371 ARGUMENTS:\n\
5372 \n\
5373  f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5374 \n\
5375  nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5376 \n\
5377  kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5378  kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5379  zero-based for historical backwards-compatibility reasons.\n\
5380 \n\
5381  ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5382  ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5383  zero-based for historical backwards-compatibility reasons.\n\
5384 \n\
5385  clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5386  which to draw contours.\n\
5387 \n\
5388  nlevel (PLINT, input) : Number of contour levels to draw.\n\
5389 \n\
5390  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5391  defines the transformation between the zero-based indices of the\n\
5392  matrix f and the world coordinates.For the C case, transformation\n\
5393  functions are provided in the PLplot library: pltr0 for the\n\
5394  identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5395  respectively defined by vectors and matrices. In addition, C\n\
5396  callback routines for the transformation can be supplied by the\n\
5397  user such as the mypltr function in examples/c/x09c.c which\n\
5398  provides a general linear transformation between index coordinates\n\
5399  and world coordinates.For languages other than C you should\n\
5400  consult the PLplot documentation for the details concerning how\n\
5401  PLTRANSFORM_callback arguments are interfaced. However, in\n\
5402  general, a particular pattern of callback-associated arguments\n\
5403  such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5404  yg matrices are respectively interfaced to a linear-transformation\n\
5405  routine similar to the above mypltr function; pltr1; and pltr2.\n\
5406  Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5407  the PLplot documentation) support native language callbacks for\n\
5408  handling index to world-coordinate transformations. Examples of\n\
5409  these various approaches are given in examples/<language>x09*,\n\
5410  examples/<language>x16*, examples/<language>x20*,\n\
5411  examples/<language>x21*, and examples/<language>x22*, for all our\n\
5412  supported languages.\n\
5413 \n\
5414  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5415  information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5416  that is externally supplied.\n\
5417 ";
5418 static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
5419 Set line style\n\
5420 \n\
5421 DESCRIPTION:\n\
5422 \n\
5423  This sets up the line style for all lines subsequently drawn. A line\n\
5424  consists of segments in which the pen is alternately down and up. The\n\
5425  lengths of these segments are passed in the vectors mark and space\n\
5426  respectively. The number of mark-space pairs is specified by nms. In\n\
5427  order to return the line style to the default continuous line, plstyl\n\
5428  should be called with nms =0 .(see also pllsty)\n\
5429 \n\
5430  Redacted form: plstyl(mark, space)\n\
5431 \n\
5432  This function is used in examples 1, 9, and 14.\n\
5433 \n\
5434 \n\
5435 \n\
5436 SYNOPSIS:\n\
5437 \n\
5438 plstyl(nms, mark, space)\n\
5439 \n\
5440 ARGUMENTS:\n\
5441 \n\
5442  nms (PLINT, input) : The number of mark and space elements in a\n\
5443  line. Thus a simple broken line can be obtained by setting nms=1\n\
5444  . A continuous line is specified by setting nms=0 .\n\
5445 \n\
5446  mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5447  segments during which the pen is down, measured in micrometers.\n\
5448 \n\
5449  space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5450  the segments during which the pen is up, measured in micrometers.\n\
5451 ";
5452 static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
5453 Set the cmap0 palette using the specified cmap0*.pal format file\n\
5454 \n\
5455 DESCRIPTION:\n\
5456 \n\
5457  Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5458 \n\
5459  Redacted form: plspal0(filename)\n\
5460 \n\
5461  This function is in example 16.\n\
5462 \n\
5463 \n\
5464 \n\
5465 SYNOPSIS:\n\
5466 \n\
5467 plspal0(filename)\n\
5468 \n\
5469 ARGUMENTS:\n\
5470 \n\
5471  filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5472  containing the name of the cmap0*.pal file. If this string is\n\
5473  empty, use the default cmap0*.pal file.\n\
5474 ";
5475 static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
5476 Set the cmap1 palette using the specified cmap1*.pal format file\n\
5477 \n\
5478 DESCRIPTION:\n\
5479 \n\
5480  Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5481 \n\
5482  Redacted form: plspal1(filename, interpolate)\n\
5483 \n\
5484  This function is used in example 16.\n\
5485 \n\
5486 \n\
5487 \n\
5488 SYNOPSIS:\n\
5489 \n\
5490 plspal1(filename, interpolate)\n\
5491 \n\
5492 ARGUMENTS:\n\
5493 \n\
5494  filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5495  containing the name of the cmap1*.pal file. If this string is\n\
5496  empty, use the default cmap1*.pal file.\n\
5497 \n\
5498  interpolate (PLBOOL, input) : If this parameter is true, the\n\
5499  columns containing the intensity index, r, g, b, alpha and\n\
5500  alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5501  palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5502  a flag which controls whether the r, g, b data sent to plscmap1la\n\
5503  are interpreted as HLS or RGB.) If this parameter is false, the\n\
5504  intensity index and alt_hue_path columns are ignored and the r, g,\n\
5505  b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5506  are used instead to set the cmap1 palette directly with a call to\n\
5507  plscmap1a.\n\
5508 ";
5509 static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
5510 Set current output stream\n\
5511 \n\
5512 DESCRIPTION:\n\
5513 \n\
5514  Sets the number of the current output stream. The stream number\n\
5515  defaults to 0 unless changed by this routine. The first use of this\n\
5516  routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5517 \n\
5518  Redacted form: plsstrm(strm)\n\
5519 \n\
5520  This function is examples 1,14,20.\n\
5521 \n\
5522 \n\
5523 \n\
5524 SYNOPSIS:\n\
5525 \n\
5526 plsstrm(strm)\n\
5527 \n\
5528 ARGUMENTS:\n\
5529 \n\
5530  strm (PLINT, input) : The current stream number.\n\
5531 ";
5532 static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
5533 Specify viewport using normalized subpage coordinates\n\
5534 \n\
5535 DESCRIPTION:\n\
5536 \n\
5537  Device-independent routine for setting up the viewport. This defines\n\
5538  the viewport in terms of normalized subpage coordinates which run from\n\
5539  0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5540  current subpage. Use the alternate routine plsvpa in order to create\n\
5541  a viewport of a definite size.\n\
5542 \n\
5543  Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5544 \n\
5545  This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5546  24, 26, 27, and 31.\n\
5547 \n\
5548 \n\
5549 \n\
5550 SYNOPSIS:\n\
5551 \n\
5552 plvpor(xmin, xmax, ymin, ymax)\n\
5553 \n\
5554 ARGUMENTS:\n\
5555 \n\
5556  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5557  left-hand edge of the viewport.\n\
5558 \n\
5559  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5560  right-hand edge of the viewport.\n\
5561 \n\
5562  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5563  bottom edge of the viewport.\n\
5564 \n\
5565  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5566  edge of the viewport.\n\
5567 ";
5568 static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
5569 Write text inside the viewport\n\
5570 \n\
5571 DESCRIPTION:\n\
5572 \n\
5573  Writes text at a specified position and inclination within the\n\
5574  viewport. Text is clipped at the viewport boundaries. The reference\n\
5575  point of a string lies along a line passing through the string at half\n\
5576  the height of a capital letter. The position of the reference point\n\
5577  along this line is determined by just, the reference point is placed\n\
5578  at world coordinates (\n\
5579  x,\n\
5580  y) within the viewport. The inclination of the string is specified\n\
5581  in terms of differences of world coordinates making it easy to write\n\
5582  text parallel to a line in a graph.\n\
5583 \n\
5584  Redacted form: plptex(x, y, dx, dy, just, text)\n\
5585 \n\
5586  This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5587 \n\
5588 \n\
5589 \n\
5590 SYNOPSIS:\n\
5591 \n\
5592 plptex(x, y, dx, dy, just, text)\n\
5593 \n\
5594 ARGUMENTS:\n\
5595 \n\
5596  x (PLFLT, input) : x coordinate of reference point of string.\n\
5597 \n\
5598  y (PLFLT, input) : y coordinate of reference point of string.\n\
5599 \n\
5600  dx (PLFLT, input) : Together with dy, this specifies the\n\
5601  inclination of the string. The baseline of the string is parallel\n\
5602  to a line joining (\n\
5603  x,\n\
5604  y) to (\n\
5605  x+\n\
5606  dx,\n\
5607  y+\n\
5608  dy) .\n\
5609 \n\
5610  dy (PLFLT, input) : Together with dx, this specifies the\n\
5611  inclination of the string.\n\
5612 \n\
5613  just (PLFLT, input) : Specifies the position of the string relative\n\
5614  to its reference point. If just=0. , the reference point is at\n\
5615  the left and if just=1. , it is at the right of the string. Other\n\
5616  values of just give intermediate justifications.\n\
5617 \n\
5618  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5619  written out.\n\
5620 ";
5621 static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
5622 Set z axis parameters\n\
5623 \n\
5624 DESCRIPTION:\n\
5625 \n\
5626  Identical to plsxax, except that arguments are flags for z axis. See\n\
5627  the description of plsxax for more detail.\n\
5628 \n\
5629  Redacted form: plszax(digmax, digits)\n\
5630 \n\
5631  This function is used in example 31.\n\
5632 \n\
5633 \n\
5634 \n\
5635 SYNOPSIS:\n\
5636 \n\
5637 plszax(digmax, digits)\n\
5638 \n\
5639 ARGUMENTS:\n\
5640 \n\
5641  digmax (PLINT, input) : Variable to set the maximum number of\n\
5642  digits for the z axis. If nonzero, the printed label will be\n\
5643  switched to a floating-point representation when the number of\n\
5644  digits exceeds digmax.\n\
5645 \n\
5646  digits (PLINT, input) : Field digits value. Currently, changing\n\
5647  its value here has no effect since it is set only by plbox or\n\
5648  plbox3. However, the user may obtain its value after a call to\n\
5649  either of these functions by calling plgzax.\n\
5650 ";
5651 static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
5652 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5653 \n\
5654 DESCRIPTION:\n\
5655 \n\
5656  This variant of plsurf3d (see that function\'s documentation for more\n\
5657  details) should be suitable for the case where the area of the x, y\n\
5658  coordinate grid where z is defined can be non-rectangular. The limits\n\
5659  of that grid are provided by the parameters indexxmin, indexxmax,\n\
5660  indexymin, and indexymax.\n\
5661 \n\
5662  Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5663  indexymax)\n\
5664 \n\
5665  This function is used in example 8.\n\
5666 \n\
5667 \n\
5668 \n\
5669 SYNOPSIS:\n\
5670 \n\
5671 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5672 \n\
5673 ARGUMENTS:\n\
5674 \n\
5675  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5676  which the function is evaluated.\n\
5677 \n\
5678  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5679  which the function is evaluated.\n\
5680 \n\
5681  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5682  plot. Should have dimensions of\n\
5683  nx by\n\
5684  ny.\n\
5685 \n\
5686  nx (PLINT, input) : Number of x values at which function is\n\
5687  evaluated.\n\
5688 \n\
5689  ny (PLINT, input) : Number of y values at which function is\n\
5690  evaluated.\n\
5691 \n\
5692  opt (PLINT, input) : Determines the way in which the surface is\n\
5693  represented. To specify more than one option just add the options,\n\
5694  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5695  connecting points at which function is defined.\n\
5696  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5697  using parameters\n\
5698  nlevel and\n\
5699  clevel.\n\
5700  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5701  using parameters\n\
5702  nlevel and\n\
5703  clevel.\n\
5704  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5705  the borders of the plotted function.\n\
5706  opt=MAG_COLOR : the surface is colored according to the value\n\
5707  of Z; if MAG_COLOR is not used, then the surface is colored\n\
5708  according to the intensity of the reflected light in the\n\
5709  surface from a light source whose position is set using\n\
5710  pllightsource.\n\
5711 \n\
5712 \n\
5713  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5714  levels.\n\
5715 \n\
5716  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5717 \n\
5718  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5719  corresponds to the first x index where z is defined.\n\
5720 \n\
5721  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5722  which corresponds (by convention) to one more than the last x\n\
5723  index value where z is defined.\n\
5724 \n\
5725  indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5726  values which all must be ≥ 0. These values are the first y index\n\
5727  where z is defined for a particular x index in the range from\n\
5728  indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5729  indexxmax.\n\
5730 \n\
5731  indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5732  values which all must be ≤ ny. These values correspond (by\n\
5733  convention) to one more than the last y index where z is defined\n\
5734  for a particular x index in the range from indexxmin to indexxmax\n\
5735  - 1. The dimension of indexymax is indexxmax.\n\
5736 ";
5737 static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
5738 Set font\n\
5739 \n\
5740 DESCRIPTION:\n\
5741 \n\
5742  Sets the font used for subsequent text and symbols. For devices that\n\
5743  still use Hershey fonts this routine has no effect unless the Hershey\n\
5744  fonts with extended character set are loaded (see plfontld). For\n\
5745  unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5746  this routine calls the plsfci routine with argument set up\n\
5747  appropriately for the various cases below. However, this method of\n\
5748  specifying the font for unicode-aware devices is deprecated, and the\n\
5749  much more flexible method of calling plsfont directly is recommended\n\
5750  instead (where plsfont provides a user-friendly interface to plsfci),\n\
5751 \n\
5752  Redacted form: plfont(ifont)\n\
5753 \n\
5754  This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5755 \n\
5756 \n\
5757 \n\
5758 SYNOPSIS:\n\
5759 \n\
5760 plfont(ifont)\n\
5761 \n\
5762 ARGUMENTS:\n\
5763 \n\
5764  ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5765  (simplest and fastest)\n\
5766  2: Serif font\n\
5767  3: Italic font\n\
5768  4: Script font\n\
5769 ";
5770 static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
5771 Get the cmap1 argument range for continuous color plots\n\
5772 \n\
5773 DESCRIPTION:\n\
5774 \n\
5775  Get the cmap1 argument range for continuous color plots. (Use\n\
5776  plscmap1_range to set the cmap1 argument range.)\n\
5777 \n\
5778  Redacted form: plgcmap1_range(min_color, max_color)\n\
5779 \n\
5780  This function is currently not used in any example.\n\
5781 \n\
5782 \n\
5783 \n\
5784 SYNOPSIS:\n\
5785 \n\
5786 plgcmap1_range(min_color, max_color)\n\
5787 \n\
5788 ARGUMENTS:\n\
5789 \n\
5790  min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5791  minimum cmap1 argument.\n\
5792 \n\
5793  max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5794  maximum cmap1 argument.\n\
5795 ";
5796 static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
5797 Set the cmap1 argument range for continuous color plots\n\
5798 \n\
5799 DESCRIPTION:\n\
5800 \n\
5801  Set the cmap1 argument range for continuous color plots that\n\
5802  corresponds to the range of data values. The maximum range\n\
5803  corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5804  the cmap1 argument range that is specified with this routine, the\n\
5805  smaller the subset of the cmap1 color palette that is used to\n\
5806  represent the continuous data being plotted. If\n\
5807  min_color is greater than\n\
5808  max_color or\n\
5809  max_color is greater than 1.0 or\n\
5810  min_color is less than 0.0 then no change is made to the cmap1\n\
5811  argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5812 \n\
5813  Redacted form: plscmap1_range(min_color, max_color)\n\
5814 \n\
5815  This function is currently used in example 33.\n\
5816 \n\
5817 \n\
5818 \n\
5819 SYNOPSIS:\n\
5820 \n\
5821 plscmap1_range(min_color, max_color)\n\
5822 \n\
5823 ARGUMENTS:\n\
5824 \n\
5825  min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5826  than 0.0, then 0.0 is used instead.\n\
5827 \n\
5828  max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5829  than 1.0, then 1.0 is used instead.\n\
5830 ";
5831 static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
5832 Draw a circular or elliptical arc\n\
5833 \n\
5834 DESCRIPTION:\n\
5835 \n\
5836  Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5837  semiminor axis b, starting at angle1 and ending at angle2.\n\
5838 \n\
5839  Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5840  fill)\n\
5841 \n\
5842 \n\
5843  This function is used in examples 3 and 27.\n\
5844 \n\
5845 \n\
5846 \n\
5847 SYNOPSIS:\n\
5848 \n\
5849 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5850 \n\
5851 ARGUMENTS:\n\
5852 \n\
5853  x (PLFLT, input) : X coordinate of arc center.\n\
5854 \n\
5855  y (PLFLT, input) : Y coordinate of arc center.\n\
5856 \n\
5857  a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5858 \n\
5859  b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5860 \n\
5861  angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5862  semimajor axis.\n\
5863 \n\
5864  angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5865  semimajor axis.\n\
5866 \n\
5867  rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5868  X-axis.\n\
5869 \n\
5870  fill (PLBOOL, input) : Draw a filled arc.\n\
5871 ";
5872 static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5873 Plot 3-d surface plot\n\
5874 \n\
5875 DESCRIPTION:\n\
5876 \n\
5877  Plots a three-dimensional surface plot within the environment set up\n\
5878  by plw3d. The surface is defined by the matrix z[\n\
5879  nx][\n\
5880  ny] , the point z[i][j] being the value of the function at (\n\
5881  x[i],\n\
5882  y[j]). Note that the points in vectors x and y do not need to be\n\
5883  equally spaced, but must be stored in ascending order. The parameter\n\
5884  opt controls the way in which the surface is displayed. For further\n\
5885  details see the PLplot documentation. The only difference between\n\
5886  plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5887  while plot3d only draws the surface as viewed from the top.\n\
5888 \n\
5889  Redacted form: plot3d(x, y, z, opt, side)\n\
5890 \n\
5891  This function is used in examples 11 and 21.\n\
5892 \n\
5893 \n\
5894 \n\
5895 SYNOPSIS:\n\
5896 \n\
5897 plot3d(x, y, z, nx, ny, opt, side)\n\
5898 \n\
5899 ARGUMENTS:\n\
5900 \n\
5901  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5902  which the function is evaluated.\n\
5903 \n\
5904  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5905  which the function is evaluated.\n\
5906 \n\
5907  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5908  plot. Should have dimensions of\n\
5909  nx by\n\
5910  ny.\n\
5911 \n\
5912  nx (PLINT, input) : Number of x values at which function is\n\
5913  evaluated.\n\
5914 \n\
5915  ny (PLINT, input) : Number of y values at which function is\n\
5916  evaluated.\n\
5917 \n\
5918  opt (PLINT, input) : Determines the way in which the surface is\n\
5919  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5920  function of x for each value of y[j] .\n\
5921  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5922  for each value of x[i] .\n\
5923  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5924  at which function is defined.\n\
5925 \n\
5926 \n\
5927  side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5928  should be draw on the figure. If side is true sides are drawn,\n\
5929  otherwise no sides are drawn.\n\
5930 ";
5931 static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5932 Set area line fill pattern\n\
5933 \n\
5934 DESCRIPTION:\n\
5935 \n\
5936  Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5937  The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5938  inclinations and spacings. The arguments to this routine are the\n\
5939  number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5940  elements) specifying the inclinations in tenths of a degree and the\n\
5941  spacing in micrometers. (See also plpsty)\n\
5942 \n\
5943  Redacted form: General: plpat(inc, del)\n\
5944 \n\
5945 \n\
5946  This function is used in example 15.\n\
5947 \n\
5948 \n\
5949 \n\
5950 SYNOPSIS:\n\
5951 \n\
5952 plpat(nlin, inc, del)\n\
5953 \n\
5954 ARGUMENTS:\n\
5955 \n\
5956  nlin (PLINT, input) : Number of sets of lines making up the\n\
5957  pattern, either 1 or 2.\n\
5958 \n\
5959  inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5960  inclination in tenths of a degree. (Should be between -900 and\n\
5961  900).\n\
5962 \n\
5963  del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5964  spacing in micrometers between the lines making up the pattern.\n\
5965 ";
5966 static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
5967 Get x axis parameters\n\
5968 \n\
5969 DESCRIPTION:\n\
5970 \n\
5971  Returns current values of the p_digmax and p_digits flags for the x\n\
5972  axis. p_digits is updated after the plot is drawn, so this routine\n\
5973  should only be called after the call to plbox (or plbox3) is complete.\n\
5974  See the PLplot documentation for more information.\n\
5975 \n\
5976  Redacted form: plgxax(p_digmax, p_digits)\n\
5977 \n\
5978  This function is used in example 31.\n\
5979 \n\
5980 \n\
5981 \n\
5982 SYNOPSIS:\n\
5983 \n\
5984 plgxax(p_digmax, p_digits)\n\
5985 \n\
5986 ARGUMENTS:\n\
5987 \n\
5988  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5989  number of digits for the x axis. If nonzero, the printed label\n\
5990  has been switched to a floating-point representation when the\n\
5991  number of digits exceeds this value.\n\
5992 \n\
5993  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
5994  number of digits for the numeric labels (x axis) from the last\n\
5995  plot.\n\
5996 ";
5997 static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
5998 Draw filled polygon in 3D\n\
5999 \n\
6000 DESCRIPTION:\n\
6001 \n\
6002  Fills the 3D polygon defined by the n points in the x, y, and z\n\
6003  vectors using the pattern defined by plpsty or plpat. The routine\n\
6004  will automatically close the polygon between the last and first\n\
6005  vertices. If multiple closed polygons are passed in x, y, and z then\n\
6006  plfill3 will fill in between them.\n\
6007 \n\
6008  Redacted form: General: plfill3(x, y, z)\n\
6009 \n\
6010 \n\
6011  This function is used in example 15.\n\
6012 \n\
6013 \n\
6014 \n\
6015 SYNOPSIS:\n\
6016 \n\
6017 plfill3(n, x, y, z)\n\
6018 \n\
6019 ARGUMENTS:\n\
6020 \n\
6021  n (PLINT, input) : Number of vertices in polygon.\n\
6022 \n\
6023  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6024  vertices.\n\
6025 \n\
6026  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6027  vertices.\n\
6028 \n\
6029  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6030  vertices.\n\
6031 ";
6032 static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6033 Set color, cmap0\n\
6034 \n\
6035 DESCRIPTION:\n\
6036 \n\
6037  Sets the color index for cmap0 (see the PLplot documentation).\n\
6038 \n\
6039  Redacted form: plcol0(icol0)\n\
6040 \n\
6041  This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6042 \n\
6043 \n\
6044 \n\
6045 SYNOPSIS:\n\
6046 \n\
6047 plcol0(icol0)\n\
6048 \n\
6049 ARGUMENTS:\n\
6050 \n\
6051  icol0 (PLINT, input) : Integer representing the color. The\n\
6052  defaults at present are (these may change):\n\
6053  0 black (default background)\n\
6054  1 red (default foreground)\n\
6055  2 yellow\n\
6056  3 green\n\
6057  4 aquamarine\n\
6058  5 pink\n\
6059  6 wheat\n\
6060  7 grey\n\
6061  8 brown\n\
6062  9 blue\n\
6063  10 BlueViolet\n\
6064  11 cyan\n\
6065  12 turquoise\n\
6066  13 magenta\n\
6067  14 salmon\n\
6068  15 white\n\
6069 \n\
6070  Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6071  change an individual color in the cmap0 color palette.\n\
6072 ";
6073 static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
6074 Draw text at points defined by Shapefile data in world coordinates\n\
6075 \n\
6076 DESCRIPTION:\n\
6077 \n\
6078  As per plmapline, however the items are plotted as text in the same\n\
6079  way as plptex.\n\
6080 \n\
6081  Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
6082  miny, maxy, plotentry)\n\
6083 \n\
6084  This function is used in example 19.\n\
6085 \n\
6086 \n\
6087 \n\
6088 SYNOPSIS:\n\
6089 \n\
6090 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
6091 \n\
6092 ARGUMENTS:\n\
6093 \n\
6094  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6095  transform the coordinates given in the shapefile into a plot\n\
6096  coordinate system. By using this transform, we can change from a\n\
6097  longitude, latitude coordinate to a polar stereographic project,\n\
6098  for example. Initially, x[0]..[n-1] are the longitudes and\n\
6099  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6100  mapform(), x[] and y[] should be replaced by the corresponding\n\
6101  plot coordinates. If no transform is desired, mapform can be\n\
6102  replaced by NULL.\n\
6103 \n\
6104  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6105  the file name of a set of Shapefile files without the file\n\
6106  extension.\n\
6107 \n\
6108  dx (PLFLT, input) : Used to define the slope of the texts which is\n\
6109  dy/dx.\n\
6110 \n\
6111  dy (PLFLT, input) : Used to define the slope of the texts which is\n\
6112  dy/dx.\n\
6113 \n\
6114  just (PLFLT, input) : Set the justification of the text. The value\n\
6115  given will be the fraction of the distance along the string that\n\
6116  sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
6117  centralized text and 1.0 gives right aligned text.\n\
6118 \n\
6119  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
6120 \n\
6121  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6122  be in the same units as used by the Shapefile. You could use a\n\
6123  very large negative number to plot everything, but you can improve\n\
6124  performance by limiting the area drawn. The units must match those\n\
6125  of the Shapefile projection, which may be for example longitude or\n\
6126  distance. The value of minx must be less than the value of maxx.\n\
6127 \n\
6128  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6129  use a very large number to plot everything, but you can improve\n\
6130  performance by limiting the area drawn.\n\
6131 \n\
6132  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6133  be in the same units as used by the Shapefile. You could use a\n\
6134  very large negative number to plot everything, but you can improve\n\
6135  performance by limiting the area drawn. The units must match those\n\
6136  of the Shapefile projection, which may be for example latitude or\n\
6137  distance. The value of miny must be less than the value of maxy.\n\
6138 \n\
6139  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6140  use a very large number to plot everything, but you can improve\n\
6141  performance by limiting the area drawn.\n\
6142 \n\
6143  plotentry (PLINT, input) : An integer indicating which text string\n\
6144  of the Shapefile (zero indexed) will be drawn.\n\
6145 ";
6146 static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
6147 Draw a line between two points\n\
6148 \n\
6149 DESCRIPTION:\n\
6150 \n\
6151  Joins the point (\n\
6152  x1,\n\
6153  y1) to (\n\
6154  x2,\n\
6155  y2).\n\
6156 \n\
6157  Redacted form: pljoin(x1,y1,x2,y2)\n\
6158 \n\
6159  This function is used in examples 3 and 14.\n\
6160 \n\
6161 \n\
6162 \n\
6163 SYNOPSIS:\n\
6164 \n\
6165 pljoin(x1, y1, x2, y2)\n\
6166 \n\
6167 ARGUMENTS:\n\
6168 \n\
6169  x1 (PLFLT, input) : x coordinate of first point.\n\
6170 \n\
6171  y1 (PLFLT, input) : y coordinate of first point.\n\
6172 \n\
6173  x2 (PLFLT, input) : x coordinate of second point.\n\
6174 \n\
6175  y2 (PLFLT, input) : y coordinate of second point.\n\
6176 ";
6177 static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6178 Set color, cmap1\n\
6179 \n\
6180 DESCRIPTION:\n\
6181 \n\
6182  Sets the color for cmap1 (see the PLplot documentation).\n\
6183 \n\
6184  Redacted form: plcol1(col1)\n\
6185 \n\
6186  This function is used in examples 12 and 21.\n\
6187 \n\
6188 \n\
6189 \n\
6190 SYNOPSIS:\n\
6191 \n\
6192 plcol1(col1)\n\
6193 \n\
6194 ARGUMENTS:\n\
6195 \n\
6196  col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6197  is mapped to color using the continuous cmap1 palette which by\n\
6198  default ranges from blue to the background color to red. The\n\
6199  cmap1 palette can also be straightforwardly changed by the user\n\
6200  with plscmap1 or plscmap1l.\n\
6201 ";
6202 static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
6203 Set orientation\n\
6204 \n\
6205 DESCRIPTION:\n\
6206 \n\
6207  Set integer plot orientation parameter. This function is identical to\n\
6208  plsdiori except for the type of the argument, and should be used in\n\
6209  the same way. See the documentation of plsdiori for details.\n\
6210 \n\
6211  Redacted form: plsori(ori)\n\
6212 \n\
6213  This function is used in example 3.\n\
6214 \n\
6215 \n\
6216 \n\
6217 SYNOPSIS:\n\
6218 \n\
6219 plsori(ori)\n\
6220 \n\
6221 ARGUMENTS:\n\
6222 \n\
6223  ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
6224  portrait, etc.) The value is multiplied by 90 degrees to get the\n\
6225  angle.\n\
6226 ";
6227 static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6228 Calculate continuous time from broken-down time for the current stream\n\
6229 \n\
6230 DESCRIPTION:\n\
6231 \n\
6232  Calculate continuous time, ctime, from broken-down time for the\n\
6233  current stream. The broken-down\n\
6234  time is specified by the following parameters: year, month, day, hour,\n\
6235  min, and sec. This function is the inverse of plbtime.\n\
6236 \n\
6237  The PLplot definition of broken-down time is a calendar time that\n\
6238  completely ignores all time zone offsets, i.e., it is the user\'s\n\
6239  responsibility to apply those offsets (if so desired) before using the\n\
6240  PLplot time API. By default broken-down time is defined using the\n\
6241  proleptic Gregorian calendar without the insertion of leap seconds and\n\
6242  continuous time is defined as the number of seconds since the Unix\n\
6243  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6244  broken-down and continuous time are possible, see plconfigtime which\n\
6245  specifies that transformation for the current stream.\n\
6246 \n\
6247  Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6248  ctime)\n\
6249 \n\
6250 \n\
6251  This function is used in example 29.\n\
6252 \n\
6253 \n\
6254 \n\
6255 SYNOPSIS:\n\
6256 \n\
6257 plctime(year, month, day, hour, min, sec, ctime)\n\
6258 \n\
6259 ARGUMENTS:\n\
6260 \n\
6261  year (PLINT, input) : Input year.\n\
6262 \n\
6263  month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6264  (December).\n\
6265 \n\
6266  day (PLINT, input) : Input day in range from 1 to 31.\n\
6267 \n\
6268  hour (PLINT, input) : Input hour in range from 0 to 23\n\
6269 \n\
6270  min (PLINT, input) : Input minute in range from 0 to 59.\n\
6271 \n\
6272  sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6273 \n\
6274  ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6275  time calculated from the broken-down time specified by the\n\
6276  previous parameters.\n\
6277 ";
6278 static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
6279 Plot continental outline or shapefile data in world coordinates\n\
6280 \n\
6281 DESCRIPTION:\n\
6282 \n\
6283  Plots continental outlines or shapefile data in world coordinates. A\n\
6284  demonstration of how to use this function to create different\n\
6285  projections can be found in examples/c/x19c. PLplot is provided with\n\
6286  basic coastal outlines and USA state borders. To use the map\n\
6287  functionality PLplot must be compiled with the shapelib library.\n\
6288  Shapefiles have become a popular standard for geographical data and\n\
6289  data in this format can be easily found from a number of online\n\
6290  sources. Shapefile data is actually provided as three or more files\n\
6291  with the same filename, but different extensions. The .shp and .shx\n\
6292  files are required for plotting Shapefile data with PLplot.\n\
6293 \n\
6294  PLplot currently supports the point, multipoint, polyline and polygon\n\
6295  objects within shapefiles. However holes in polygons are not\n\
6296  supported. When plmap is used the type of object is derived from the\n\
6297  shapefile, if you wish to override the type then use one of the other\n\
6298  plmap variants. The built in maps have line data only.\n\
6299 \n\
6300  Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
6301 \n\
6302  This function is used in example 19.\n\
6303 \n\
6304 \n\
6305 \n\
6306 SYNOPSIS:\n\
6307 \n\
6308 plmap(mapform, name, minx, maxx, miny, maxy)\n\
6309 \n\
6310 ARGUMENTS:\n\
6311 \n\
6312  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6313  transform the original map data coordinates to a new coordinate\n\
6314  system. The PLplot-supplied map data is provided as latitudes and\n\
6315  longitudes; other Shapefile data may be provided in other\n\
6316  coordinate systems as can be found in their .prj plain text files.\n\
6317  For example, by using this transform we can change from a\n\
6318  longitude, latitude coordinate to a polar stereographic\n\
6319  projection. Initially, x[0]..[n-1] are the original x coordinates\n\
6320  (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
6321  corresponding y coordinates (latitudes for the PLplot supplied\n\
6322  data). After the call to mapform(), x[] and y[] should be\n\
6323  replaced by the corresponding plot coordinates. If no transform is\n\
6324  desired, mapform can be replaced by NULL.\n\
6325 \n\
6326  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6327  the type of map plotted. This is either one of the PLplot built-in\n\
6328  maps or the file name of a set of Shapefile files without the file\n\
6329  extensions. For the PLplot built-in maps the possible values are:\n\
6330  \"globe\" -- continental outlines\n\
6331  \"usa\" -- USA and state boundaries\n\
6332  \"cglobe\" -- continental outlines and countries\n\
6333  \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6334 \n\
6335 \n\
6336  minx (PLFLT, input) : The minimum x value of map elements to be\n\
6337  drawn. The units must match the shapefile (built in maps are\n\
6338  degrees lat/lon). Objects in the file which do not encroach on the\n\
6339  box defined by minx, maxx, miny, maxy will not be rendered. But\n\
6340  note this is simply an optimisation, not a clipping so for objects\n\
6341  with some points inside the box and some points outside the box\n\
6342  all the points will be rendered. These parameters also define\n\
6343  latitude and longitude wrapping for shapefiles using these units.\n\
6344  Longitude points will be wrapped by integer multiples of 360\n\
6345  degrees to place them in the box. This allows the same data to be\n\
6346  used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
6347  you plot from -180-540 you will get two cycles of data drawn. The\n\
6348  value of minx must be less than the value of maxx. Passing in a\n\
6349  nan, max/-max floating point number or +/-infinity will case the\n\
6350  bounding box from the shapefile to be used.\n\
6351 \n\
6352  maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6353  drawn - see minx.\n\
6354 \n\
6355  miny (PLFLT, input) : The minimum y value of map elements to be\n\
6356  drawn - see minx.\n\
6357 \n\
6358  maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6359  drawn - see minx.\n\
6360 ";
6361 static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
6362 Calculate broken-down time from continuous time for the current stream\n\
6363 \n\
6364 DESCRIPTION:\n\
6365 \n\
6366  Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6367  continuous time, ctime for the current stream. This function is the\n\
6368  inverse of plctime.\n\
6369 \n\
6370  The PLplot definition of broken-down time is a calendar time that\n\
6371  completely ignores all time zone offsets, i.e., it is the user\'s\n\
6372  responsibility to apply those offsets (if so desired) before using the\n\
6373  PLplot time API. By default broken-down time is defined using the\n\
6374  proleptic Gregorian calendar without the insertion of leap seconds and\n\
6375  continuous time is defined as the number of seconds since the Unix\n\
6376  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6377  broken-down and continuous time are possible, see plconfigtime.\n\
6378 \n\
6379  Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6380  ctime)\n\
6381 \n\
6382 \n\
6383  This function is used in example 29.\n\
6384 \n\
6385 \n\
6386 \n\
6387 SYNOPSIS:\n\
6388 \n\
6389 plbtime(year, month, day, hour, min, sec, ctime)\n\
6390 \n\
6391 ARGUMENTS:\n\
6392 \n\
6393  year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6394  positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6395  non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6396  BCE, etc.)\n\
6397 \n\
6398  month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6399  the year in the range from 0 (January) to 11 (December).\n\
6400 \n\
6401  day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6402  month in the range from 1 to 31.\n\
6403 \n\
6404  hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6405  day in the range from 0 to 23.\n\
6406 \n\
6407  min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6408  hour in the range from 0 to 59\n\
6409 \n\
6410  sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6411  minute in range from 0. to 60.\n\
6412 \n\
6413  ctime (PLFLT, input) : Continuous time from which the broken-down\n\
6414  time is calculated.\n\
6415 ";
6416 static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
6417 Get current stream number\n\
6418 \n\
6419 DESCRIPTION:\n\
6420 \n\
6421  Gets the number of the current output stream. See also plsstrm.\n\
6422 \n\
6423  Redacted form: plgstrm(p_strm)\n\
6424 \n\
6425  This function is used in example 1,20.\n\
6426 \n\
6427 \n\
6428 \n\
6429 SYNOPSIS:\n\
6430 \n\
6431 plgstrm(p_strm)\n\
6432 \n\
6433 ARGUMENTS:\n\
6434 \n\
6435  p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6436  stream value.\n\
6437 ";
6438 static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
6439 Draw a line in 3 space\n\
6440 \n\
6441 DESCRIPTION:\n\
6442 \n\
6443  Draws line in 3 space defined by n points in x, y, and z. You must\n\
6444  first set up the viewport, the 2d viewing window (in world\n\
6445  coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6446  more info.\n\
6447 \n\
6448  Redacted form: plline3(x, y, z)\n\
6449 \n\
6450  This function is used in example 18.\n\
6451 \n\
6452 \n\
6453 \n\
6454 SYNOPSIS:\n\
6455 \n\
6456 plline3(n, x, y, z)\n\
6457 \n\
6458 ARGUMENTS:\n\
6459 \n\
6460  n (PLINT, input) : Number of points defining line.\n\
6461 \n\
6462  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6463  points.\n\
6464 \n\
6465  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6466  points.\n\
6467 \n\
6468  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6469  points.\n\
6470 ";
6471 static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
6472 Load Hershey fonts\n\
6473 \n\
6474 DESCRIPTION:\n\
6475 \n\
6476  Loads the Hershey fonts used for text and symbols. This routine may\n\
6477  be called before or after initializing PLplot. If not explicitly\n\
6478  called before PLplot initialization, then by default that\n\
6479  initialization loads Hershey fonts with the extended character set.\n\
6480  This routine only has a practical effect for devices that still use\n\
6481  Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6482  system fonts instead of Hershey fonts).\n\
6483 \n\
6484  Redacted form: plfontld(fnt)\n\
6485 \n\
6486  This function is used in examples 1 and 7.\n\
6487 \n\
6488 \n\
6489 \n\
6490 SYNOPSIS:\n\
6491 \n\
6492 plfontld(fnt)\n\
6493 \n\
6494 ARGUMENTS:\n\
6495 \n\
6496  fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6497  A zero value specifies Hershey fonts with the standard character\n\
6498  set and a non-zero value (the default assumed if plfontld is never\n\
6499  called) specifies Hershey fonts with the extended character set.\n\
6500 ";
6501 static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
6502 Set any command-line option\n\
6503 \n\
6504 DESCRIPTION:\n\
6505 \n\
6506  Set any command-line option internally from a program before it\n\
6507  invokes plinit. opt is the name of the command-line option and optarg\n\
6508  is the corresponding command-line option argument.\n\
6509 \n\
6510  This function returns 0 on success.\n\
6511 \n\
6512  Redacted form: plsetopt(opt, optarg)\n\
6513 \n\
6514  This function is used in example 14.\n\
6515 \n\
6516 \n\
6517 \n\
6518 SYNOPSIS:\n\
6519 \n\
6520 PLINT plsetopt(opt, optarg)\n\
6521 \n\
6522 ARGUMENTS:\n\
6523 \n\
6524  opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6525  the command-line option.\n\
6526 \n\
6527  optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6528  containing the argument of the command-line option.\n\
6529 ";
6530 static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
6531 Plot all or a subset of Shapefile data using lines in world coordinates\n\
6532 \n\
6533 DESCRIPTION:\n\
6534 \n\
6535  Plot all or a subset of Shapefile data using lines in world\n\
6536  coordinates. Our 19th standard example demonstrates how to use this\n\
6537  function. This function plots data from a Shapefile using lines as in\n\
6538  plmap, however it also has the option of also only drawing specified\n\
6539  elements from the Shapefile. The vector of indices of the required\n\
6540  elements are passed as a function argument. The Shapefile data should\n\
6541  include a metadata file (extension.dbf) listing all items within the\n\
6542  Shapefile. This file can be opened by most popular spreadsheet\n\
6543  programs and can be used to decide which indices to pass to this\n\
6544  function.\n\
6545 \n\
6546  Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6547  plotentries)\n\
6548 \n\
6549  This function is used in example 19.\n\
6550 \n\
6551 \n\
6552 \n\
6553 SYNOPSIS:\n\
6554 \n\
6555 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6556 \n\
6557 ARGUMENTS:\n\
6558 \n\
6559  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6560  transform the coordinates given in the shapefile into a plot\n\
6561  coordinate system. By using this transform, we can change from a\n\
6562  longitude, latitude coordinate to a polar stereographic project,\n\
6563  for example. Initially, x[0]..[n-1] are the longitudes and\n\
6564  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6565  mapform(), x[] and y[] should be replaced by the corresponding\n\
6566  plot coordinates. If no transform is desired, mapform can be\n\
6567  replaced by NULL.\n\
6568 \n\
6569  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6570  the file name of a set of Shapefile files without the file\n\
6571  extension.\n\
6572 \n\
6573  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6574  be in the same units as used by the Shapefile. You could use a\n\
6575  very large negative number to plot everything, but you can improve\n\
6576  performance by limiting the area drawn. The units must match those\n\
6577  of the Shapefile projection, which may be for example longitude or\n\
6578  distance. The value of minx must be less than the value of maxx.\n\
6579 \n\
6580  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6581  use a very large number to plot everything, but you can improve\n\
6582  performance by limiting the area drawn.\n\
6583 \n\
6584  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6585  be in the same units as used by the Shapefile. You could use a\n\
6586  very large negative number to plot everything, but you can improve\n\
6587  performance by limiting the area drawn. The units must match those\n\
6588  of the Shapefile projection, which may be for example latitude or\n\
6589  distance. The value of miny must be less than the value of maxy.\n\
6590 \n\
6591  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6592  use a very large number to plot everything, but you can improve\n\
6593  performance by limiting the area drawn.\n\
6594 \n\
6595  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6596  zero-based indices of the Shapefile elements which will be drawn.\n\
6597  Setting\n\
6598  plotentries to NULL will plot all elements of the Shapefile.\n\
6599 \n\
6600  nplotentries (PLINT, input) : The number of items in\n\
6601  plotentries. Ignored if\n\
6602  plotentries is NULL.\n\
6603 ";
6604 static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6605 Used to globally turn color output on/off\n\
6606 \n\
6607 DESCRIPTION:\n\
6608 \n\
6609  Used to globally turn color output on/off for those drivers/devices\n\
6610  that support it.\n\
6611 \n\
6612  Redacted form: plscolor(color)\n\
6613 \n\
6614  This function is used in example 31.\n\
6615 \n\
6616 \n\
6617 \n\
6618 SYNOPSIS:\n\
6619 \n\
6620 plscolor(color)\n\
6621 \n\
6622 ARGUMENTS:\n\
6623 \n\
6624  color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6625  turned off. If non-zero, color is turned on.\n\
6626 ";
6627 static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
6628 Wait for graphics input event and translate to world coordinates.\n\
6629 \n\
6630 DESCRIPTION:\n\
6631 \n\
6632  Wait for graphics input event and translate to world coordinates.\n\
6633  Returns 0 if no translation to world coordinates is possible.\n\
6634 \n\
6635  This function returns 1 on success and 0 if no translation to world\n\
6636  coordinates is possible.\n\
6637 \n\
6638  Redacted form: plGetCursor(gin)\n\
6639 \n\
6640  This function is used in examples 1 and 20.\n\
6641 \n\
6642 \n\
6643 \n\
6644 SYNOPSIS:\n\
6645 \n\
6646 PLINT plGetCursor(gin)\n\
6647 \n\
6648 ARGUMENTS:\n\
6649 \n\
6650  gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6651  which will contain the output. The structure is not allocated by\n\
6652  the routine and must exist before the function is called.\n\
6653 ";
6654 static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
6655 Get the current device (keyword) name\n\
6656 \n\
6657 DESCRIPTION:\n\
6658 \n\
6659  Get the current device (keyword) name. Note: you must have allocated\n\
6660  space for this (80 characters is safe).\n\
6661 \n\
6662  Redacted form: plgdev(p_dev)\n\
6663 \n\
6664  This function is used in example 14.\n\
6665 \n\
6666 \n\
6667 \n\
6668 SYNOPSIS:\n\
6669 \n\
6670 plgdev(p_dev)\n\
6671 \n\
6672 ARGUMENTS:\n\
6673 \n\
6674  p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6675  (with preallocated length of 80 characters or more) containing the\n\
6676  device (keyword) name.\n\
6677 ";
6678 static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
6679 Add a point to a strip chart\n\
6680 \n\
6681 DESCRIPTION:\n\
6682 \n\
6683  Add a point to a given pen of a given strip chart. There is no need\n\
6684  for all pens to have the same number of points or to be equally\n\
6685  sampled in the x coordinate. Allocates memory and rescales as\n\
6686  necessary.\n\
6687 \n\
6688  Redacted form: plstripa(id, pen, x, y)\n\
6689 \n\
6690  This function is used in example 17.\n\
6691 \n\
6692 \n\
6693 \n\
6694 SYNOPSIS:\n\
6695 \n\
6696 plstripa(id, pen, x, y)\n\
6697 \n\
6698 ARGUMENTS:\n\
6699 \n\
6700  id (PLINT, input) : Identification number of the strip chart (set\n\
6701  up in plstripc).\n\
6702 \n\
6703  pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6704 \n\
6705  x (PLFLT, input) : X coordinate of point to plot.\n\
6706 \n\
6707  y (PLFLT, input) : Y coordinate of point to plot.\n\
6708 ";
6709 static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
6710 Create a 4-pen strip chart\n\
6711 \n\
6712 DESCRIPTION:\n\
6713 \n\
6714  Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6715 \n\
6716  Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6717  ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6718  styline, legline, labx, laby, labz)\n\
6719 \n\
6720 \n\
6721  This function is used in example 17.\n\
6722 \n\
6723 \n\
6724 \n\
6725 SYNOPSIS:\n\
6726 \n\
6727 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6728 \n\
6729 ARGUMENTS:\n\
6730 \n\
6731  id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6732  number of the strip chart to use on plstripa and plstripd.\n\
6733 \n\
6734  xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6735  the x-axis specification as in plbox.\n\
6736 \n\
6737  yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6738  the y-axis specification as in plbox.\n\
6739 \n\
6740  xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6741  change as data are added.\n\
6742 \n\
6743  xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6744  change as data are added.\n\
6745 \n\
6746  xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6747  is multiplied by the factor (1 +\n\
6748  xjump) .\n\
6749 \n\
6750  ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6751  change as data are added.\n\
6752 \n\
6753  ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6754  change as data are added.\n\
6755 \n\
6756  xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6757 \n\
6758  ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6759 \n\
6760  y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6761  true, otherwise not.\n\
6762 \n\
6763  acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6764  otherwise slide display.\n\
6765 \n\
6766  colbox (PLINT, input) : Plot box color index (cmap0).\n\
6767 \n\
6768  collab (PLINT, input) : Legend color index (cmap0).\n\
6769 \n\
6770  colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6771  indices for the 4 pens.\n\
6772 \n\
6773  styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6774  indices for the 4 pens.\n\
6775 \n\
6776  legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6777  strings containing legends for the 4 pens.\n\
6778 \n\
6779  labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6780  the label for the x axis.\n\
6781 \n\
6782  laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6783  the label for the y axis.\n\
6784 \n\
6785  labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6786  the plot title.\n\
6787 ";
6788 static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
6789 Deletes and releases memory used by a strip chart\n\
6790 \n\
6791 DESCRIPTION:\n\
6792 \n\
6793  Deletes and releases memory used by a strip chart.\n\
6794 \n\
6795  Redacted form: plstripd(id)\n\
6796 \n\
6797  This function is used in example 17.\n\
6798 \n\
6799 \n\
6800 \n\
6801 SYNOPSIS:\n\
6802 \n\
6803 plstripd(id)\n\
6804 \n\
6805 ARGUMENTS:\n\
6806 \n\
6807  id (PLINT, input) : Identification number of strip chart to delete.\n\
6808 ";
6809 static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
6810 Specify viewport using coordinates and aspect ratio\n\
6811 \n\
6812 DESCRIPTION:\n\
6813 \n\
6814  Device-independent routine for setting up the viewport. The viewport\n\
6815  is chosen to be the largest with the given aspect ratio that fits\n\
6816  within the specified region (in terms of normalized subpage\n\
6817  coordinates). This routine is functionally equivalent to plvpor when\n\
6818  a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6819  routine reserves no extra space at the edges for labels.\n\
6820 \n\
6821  Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6822 \n\
6823  This function is used in example 9.\n\
6824 \n\
6825 \n\
6826 \n\
6827 SYNOPSIS:\n\
6828 \n\
6829 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6830 \n\
6831 ARGUMENTS:\n\
6832 \n\
6833  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6834  left-hand edge of the viewport.\n\
6835 \n\
6836  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6837  right-hand edge of the viewport.\n\
6838 \n\
6839  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6840  bottom edge of the viewport.\n\
6841 \n\
6842  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6843  edge of the viewport.\n\
6844 \n\
6845  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6846  axis.\n\
6847 ";
6848 static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
6849 Assign a function to use for generating custom axis labels\n\
6850 \n\
6851 DESCRIPTION:\n\
6852 \n\
6853  This function allows a user to provide their own function to provide\n\
6854  axis label text. The user function is given the numeric value for a\n\
6855  point on an axis and returns a string label to correspond with that\n\
6856  value. Custom axis labels can be enabled by passing appropriate\n\
6857  arguments to plenv, plbox, plbox3 and similar functions.\n\
6858 \n\
6859  This function is used in example 19.\n\
6860 \n\
6861 \n\
6862 \n\
6863 SYNOPSIS:\n\
6864 \n\
6865 plslabelfunc(label_func, label_data)\n\
6866 \n\
6867 ARGUMENTS:\n\
6868 \n\
6869  label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6870  label function. In order to reset to the default labelling, set\n\
6871  this to NULL. The labelling function parameters are, in order:\n\
6872  axis: This indicates which axis a label is being requested for.\n\
6873  The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6874 \n\
6875  value: This is the value along the axis which is being labelled.\n\
6876 \n\
6877  label_text: The string representation of the label value.\n\
6878 \n\
6879  length: The maximum length in characters allowed for label_text.\n\
6880 \n\
6881 \n\
6882  label_data (PLPointer, input) : This parameter may be used to pass\n\
6883  data to the label_func function.\n\
6884 ";
6885 static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
6886 Set length of major ticks\n\
6887 \n\
6888 DESCRIPTION:\n\
6889 \n\
6890  This sets up the length of the major ticks. The actual length is the\n\
6891  product of the default length and a scaling factor as for character\n\
6892  height.\n\
6893 \n\
6894  Redacted form: plsmaj(def, scale)\n\
6895 \n\
6896  This function is used in example 29.\n\
6897 \n\
6898 \n\
6899 \n\
6900 SYNOPSIS:\n\
6901 \n\
6902 plsmaj(def, scale)\n\
6903 \n\
6904 ARGUMENTS:\n\
6905 \n\
6906  def (PLFLT, input) : The default length of a major tick in\n\
6907  millimeters, should be set to zero if the default length is to\n\
6908  remain unchanged.\n\
6909 \n\
6910  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6911  actual tick length.\n\
6912 ";
6913 static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
6914 Get the current library version number\n\
6915 \n\
6916 DESCRIPTION:\n\
6917 \n\
6918  Get the current library version number. Note: you must have allocated\n\
6919  space for this (80 characters is safe).\n\
6920 \n\
6921  Redacted form: plgver(p_ver)\n\
6922 \n\
6923  This function is used in example 1.\n\
6924 \n\
6925 \n\
6926 \n\
6927 SYNOPSIS:\n\
6928 \n\
6929 plgver(p_ver)\n\
6930 \n\
6931 ARGUMENTS:\n\
6932 \n\
6933  p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6934  (with preallocated length of 80 characters or more) containing the\n\
6935  PLplot version number.\n\
6936 ";
6937 static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
6938 Set format of numerical label for contours\n\
6939 \n\
6940 DESCRIPTION:\n\
6941 \n\
6942  Set format of numerical label for contours.\n\
6943 \n\
6944  Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
6945 \n\
6946  This function is used example 9.\n\
6947 \n\
6948 \n\
6949 \n\
6950 SYNOPSIS:\n\
6951 \n\
6952 pl_setcontlabelformat(lexp, sigdig)\n\
6953 \n\
6954 ARGUMENTS:\n\
6955 \n\
6956  lexp (PLINT, input) : If the contour numerical label is greater\n\
6957  than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
6958  format is used. Default value of lexp is 4.\n\
6959 \n\
6960  sigdig (PLINT, input) : Number of significant digits. Default\n\
6961  value is 2.\n\
6962 ";
6963 static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6964 Parse command-line arguments\n\
6965 \n\
6966 DESCRIPTION:\n\
6967 \n\
6968  Parse command-line arguments.\n\
6969 \n\
6970  plparseopts removes all recognized flags (decreasing argc\n\
6971  accordingly), so that invalid input may be readily detected. It can\n\
6972  also be used to process user command line flags. The user can merge\n\
6973  an option table of type PLOptionTable into the internal option table\n\
6974  info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6975  the external table(s) be parsed by calling plClearOpts before\n\
6976  plMergeOpts.\n\
6977 \n\
6978  The default action taken by plparseopts is as follows:\n\
6979  Returns with an error if an unrecognized option or badly formed\n\
6980  option-value pair are encountered.\n\
6981  Returns immediately (return code 0) when the first non-option command\n\
6982  line argument is found.\n\
6983  Returns with the return code of the option handler, if one was called.\n\
6984 \n\
6985  Deletes command line arguments from argv list as they are found, and\n\
6986  decrements argc accordingly.\n\
6987  Does not show \"invisible\" options in usage or help messages.\n\
6988  Assumes the program name is contained in argv[0].\n\
6989 \n\
6990  These behaviors may be controlled through the\n\
6991  mode argument.\n\
6992 \n\
6993  Redacted form: General: plparseopts(argv, mode)\n\
6994 \n\
6995 \n\
6996  This function is used in all of the examples.\n\
6997 \n\
6998 \n\
6999 \n\
7000 SYNOPSIS:\n\
7001 \n\
7002 PLINT plparseopts(p_argc, argv, mode)\n\
7003 \n\
7004 ARGUMENTS:\n\
7005 \n\
7006  p_argc (int *, input/output) : Number of arguments.\n\
7007 \n\
7008  argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7009  strings containing *p_argc command-line arguments.\n\
7010 \n\
7011  mode (PLINT, input) : Parsing mode with the following\n\
7012  possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7013  and all error messages enabled, including program exit when an\n\
7014  error occurs. Anything on the command line that isn\'t recognized\n\
7015  as a valid option or option argument is flagged as an error.\n\
7016  PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7017  of errors.\n\
7018  PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7019  arguments.\n\
7020  PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7021  PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7022  pointer to the program name.\n\
7023  PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7024  PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7025  unrecognized arguments.\n\
7026 ";
7027 static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
7028 Initialization\n\
7029 \n\
7030 DESCRIPTION:\n\
7031 \n\
7032  Initializing the plotting package. The program prompts for the device\n\
7033  keyword or number of the desired output device. Hitting a RETURN in\n\
7034  response to the prompt is the same as selecting the first device. If\n\
7035  only one device is enabled when PLplot is installed, plstar will issue\n\
7036  no prompt. The output device is divided into nx by ny subpages, each\n\
7037  of which may be used independently. The subroutine pladv is used to\n\
7038  advance from one subpage to the next.\n\
7039 \n\
7040  Redacted form: plstar(nx, ny)\n\
7041 \n\
7042  This function is used in example 1.\n\
7043 \n\
7044 \n\
7045 \n\
7046 SYNOPSIS:\n\
7047 \n\
7048 plstar(nx, ny)\n\
7049 \n\
7050 ARGUMENTS:\n\
7051 \n\
7052  nx (PLINT, input) : Number of subpages to divide output page in the\n\
7053  x direction.\n\
7054 \n\
7055  ny (PLINT, input) : Number of subpages to divide output page in the\n\
7056  y direction.\n\
7057 ";
7058 static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
7059 Get FCI (font characterization integer)\n\
7060 \n\
7061 DESCRIPTION:\n\
7062 \n\
7063  Gets information about the current font using the FCI approach. See\n\
7064  the PLplot documentation for more information.\n\
7065 \n\
7066  Redacted form: plgfci(p_fci)\n\
7067 \n\
7068  This function is used in example 23.\n\
7069 \n\
7070 \n\
7071 \n\
7072 SYNOPSIS:\n\
7073 \n\
7074 plgfci(p_fci)\n\
7075 \n\
7076 ARGUMENTS:\n\
7077 \n\
7078  p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
7079  FCI value.\n\
7080 ";
7081 static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
7082 Set family file parameters\n\
7083 \n\
7084 DESCRIPTION:\n\
7085 \n\
7086  Sets variables dealing with output file familying. Does nothing if\n\
7087  familying not supported by the driver. This routine, if used, must be\n\
7088  called before initializing PLplot. See the PLplot documentation for\n\
7089  more information.\n\
7090 \n\
7091  Redacted form: plsfam(fam, num, bmax)\n\
7092 \n\
7093  This function is used in examples 14 and 31.\n\
7094 \n\
7095 \n\
7096 \n\
7097 SYNOPSIS:\n\
7098 \n\
7099 plsfam(fam, num, bmax)\n\
7100 \n\
7101 ARGUMENTS:\n\
7102 \n\
7103  fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
7104  is enabled.\n\
7105 \n\
7106  num (PLINT, input) : Current family file number.\n\
7107 \n\
7108  bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
7109  file.\n\
7110 ";
7111 static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
7112 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
7113 \n\
7114 DESCRIPTION:\n\
7115 \n\
7116  This is a variant of plscmap1l that supports alpha channel\n\
7117  transparency. It sets cmap1 colors using a piece-wise linear\n\
7118  relationship between cmap1 intensity index (0.0-1.0) and position in\n\
7119  HLS or RGB color space (see the PLplot documentation) with alpha\n\
7120  transparency value (0.0-1.0). It may be called at any time.\n\
7121 \n\
7122  Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
7123  alpha, alt_hue_path)\n\
7124 \n\
7125  This function is used in example 30.\n\
7126 \n\
7127 \n\
7128 \n\
7129 SYNOPSIS:\n\
7130 \n\
7131 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
7132 \n\
7133 ARGUMENTS:\n\
7134 \n\
7135  itype (PLBOOL, input) : true: RGB, false: HLS.\n\
7136 \n\
7137  npts (PLINT, input) : number of control points.\n\
7138 \n\
7139  intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
7140  intensity index (0.0-1.0) in ascending order for each control\n\
7141  point.\n\
7142 \n\
7143  coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
7144  coordinate (H or R) for each control point.\n\
7145 \n\
7146  coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
7147  coordinate (L or G) for each control point.\n\
7148 \n\
7149  coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
7150  coordinate (S or B) for each control point.\n\
7151 \n\
7152  alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
7153  transparency value (0.0-1.0) for each control point.\n\
7154 \n\
7155  alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
7156  npts - 1 elements) containing the alternative interpolation method\n\
7157  Boolean value for each control point interval. (alt_hue_path[i]\n\
7158  refers to the interpolation interval between the i and i + 1\n\
7159  control points).\n\
7160 ";
7161 static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
7162 Set page parameters\n\
7163 \n\
7164 DESCRIPTION:\n\
7165 \n\
7166  Sets the page configuration (optional). If an individual parameter is\n\
7167  zero then that parameter value is not updated. Not all parameters are\n\
7168  recognized by all drivers and the interpretation is device-dependent.\n\
7169  The X-window driver uses the length and offset parameters to determine\n\
7170  the window size and location. The length and offset values are\n\
7171  expressed in units that are specific to the current driver. For\n\
7172  instance: screen drivers will usually interpret them as number of\n\
7173  pixels, whereas printer drivers will usually use mm.\n\
7174 \n\
7175  This routine, if used, must be called before initializing PLplot. It\n\
7176  may be called at later times for interactive drivers to change only\n\
7177  the dpi for subsequent redraws which you can force via a call to\n\
7178  plreplot. If this function is not called then the page size defaults\n\
7179  to landscape A4 for drivers which use real world page sizes and 744\n\
7180  pixels wide by 538 pixels high for raster drivers. The default value\n\
7181  for dx and dy is 90 pixels per inch for raster drivers.\n\
7182 \n\
7183 \n\
7184 \n\
7185  Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7186 \n\
7187  This function is used in examples 14 and 31.\n\
7188 \n\
7189 \n\
7190 \n\
7191 SYNOPSIS:\n\
7192 \n\
7193 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7194 \n\
7195 ARGUMENTS:\n\
7196 \n\
7197  xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
7198  by raster drivers, ignored by drivers which use \"real world\" units\n\
7199  (e.g. mm).\n\
7200 \n\
7201  yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
7202  by raster drivers, ignored by drivers which use \"real world\" units\n\
7203  (e.g. mm).\n\
7204 \n\
7205  xleng (PLINT, input) : Page length, x.\n\
7206 \n\
7207  yleng (PLINT, input) : Page length, y.\n\
7208 \n\
7209  xoff (PLINT, input) : Page offset, x.\n\
7210 \n\
7211  yoff (PLINT, input) : Page offset, y.\n\
7212 ";
7213 static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7214 Set precision in numeric labels\n\
7215 \n\
7216 DESCRIPTION:\n\
7217 \n\
7218  Sets the number of places after the decimal point in numeric labels.\n\
7219 \n\
7220  Redacted form: plprec(setp, prec)\n\
7221 \n\
7222  This function is used in example 29.\n\
7223 \n\
7224 \n\
7225 \n\
7226 SYNOPSIS:\n\
7227 \n\
7228 plprec(setp, prec)\n\
7229 \n\
7230 ARGUMENTS:\n\
7231 \n\
7232  setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7233  automatically determines the number of places to use after the\n\
7234  decimal point in numeric labels (like those used to label axes).\n\
7235  If setp is 1 then prec sets the number of places.\n\
7236 \n\
7237  prec (PLINT, input) : The number of characters to draw after the\n\
7238  decimal point in numeric labels.\n\
7239 ";
7240 static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
7241 Copy state parameters from the reference stream to the current stream\n\
7242 \n\
7243 DESCRIPTION:\n\
7244 \n\
7245  Copies state parameters from the reference stream to the current\n\
7246  stream. Tell driver interface to map device coordinates unless flags\n\
7247  == 1.\n\
7248 \n\
7249  This function is used for making save files of selected plots (e.g.\n\
7250  from the TK driver). After initializing, you can get a copy of the\n\
7251  current plot to the specified device by switching to this stream and\n\
7252  issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
7253  appropriate. The plot buffer must have previously been enabled (done\n\
7254  automatically by some display drivers, such as X).\n\
7255 \n\
7256  Redacted form: plcpstrm(iplsr, flags)\n\
7257 \n\
7258  This function is used in example 1,20.\n\
7259 \n\
7260 \n\
7261 \n\
7262 SYNOPSIS:\n\
7263 \n\
7264 plcpstrm(iplsr, flags)\n\
7265 \n\
7266 ARGUMENTS:\n\
7267 \n\
7268  iplsr (PLINT, input) : Number of reference stream.\n\
7269 \n\
7270  flags (PLBOOL, input) : If flags is set to true the device\n\
7271  coordinates are not copied from the reference to current stream.\n\
7272 ";
7273 static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
7274 Plot a glyph at the specified points\n\
7275 \n\
7276 DESCRIPTION:\n\
7277 \n\
7278  Plot a glyph at the specified points. (This function is largely\n\
7279  superseded by plstring which gives access to many[!] more glyphs.)\n\
7280  code=-1 means try to just draw a point. Right now it\'s just a move\n\
7281  and a draw at the same place. Not ideal, since a sufficiently\n\
7282  intelligent output device may optimize it away, or there may be faster\n\
7283  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7284  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7285  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7286  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7287  code <= 127 the corresponding printable ASCII character is plotted.\n\
7288 \n\
7289  Redacted form: plpoin(x, y, code)\n\
7290 \n\
7291  This function is used in examples 1, 6, 14, and 29.\n\
7292 \n\
7293 \n\
7294 \n\
7295 SYNOPSIS:\n\
7296 \n\
7297 plpoin(n, x, y, code)\n\
7298 \n\
7299 ARGUMENTS:\n\
7300 \n\
7301  n (PLINT, input) : Number of points in the x and y vectors.\n\
7302 \n\
7303  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7304  points.\n\
7305 \n\
7306  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7307  points.\n\
7308 \n\
7309  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7310  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7311  each of the n points.\n\
7312 ";
7313 static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
7314 Enter or leave xor mode\n\
7315 \n\
7316 DESCRIPTION:\n\
7317 \n\
7318  Enter (when mode is true) or leave (when mode is false) xor mode for\n\
7319  those drivers (e.g., the xwin driver) that support it. Enables\n\
7320  erasing plots by drawing twice the same line, symbol, etc. If driver\n\
7321  is not capable of xor operation it returns a status of false.\n\
7322 \n\
7323  Redacted form: plxormod(mode, status)\n\
7324 \n\
7325  This function is used in examples 1 and 20.\n\
7326 \n\
7327 \n\
7328 \n\
7329 SYNOPSIS:\n\
7330 \n\
7331 plxormod(mode, status)\n\
7332 \n\
7333 ARGUMENTS:\n\
7334 \n\
7335  mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7336  is false means leave xor mode.\n\
7337 \n\
7338  status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7339  modestatus of true (false) means driver is capable (incapable) of\n\
7340  xor mode.\n\
7341 ";
7342 static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
7343 Get viewport limits in normalized device coordinates\n\
7344 \n\
7345 DESCRIPTION:\n\
7346 \n\
7347  Get viewport limits in normalized device coordinates.\n\
7348 \n\
7349  Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7350 \n\
7351 \n\
7352  This function is used in example 31.\n\
7353 \n\
7354 \n\
7355 \n\
7356 SYNOPSIS:\n\
7357 \n\
7358 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7359 \n\
7360 ARGUMENTS:\n\
7361 \n\
7362  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7363  viewport limit of the normalized device coordinate in x.\n\
7364 \n\
7365  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7366  viewport limit of the normalized device coordinate in x.\n\
7367 \n\
7368  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7369  viewport limit of the normalized device coordinate in y.\n\
7370 \n\
7371  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7372  viewport limit of the normalized device coordinate in y.\n\
7373 ";
7374 static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
7375 Plot surface mesh\n\
7376 \n\
7377 DESCRIPTION:\n\
7378 \n\
7379  Plots a surface mesh within the environment set up by plw3d. The\n\
7380  surface is defined by the matrix z[\n\
7381  nx][\n\
7382  ny] , the point z[i][j] being the value of the function at (\n\
7383  x[i],\n\
7384  y[j]). Note that the points in vectors x and y do not need to be\n\
7385  equally spaced, but must be stored in ascending order. The parameter\n\
7386  opt controls the way in which the surface is displayed. For further\n\
7387  details see the PLplot documentation.\n\
7388 \n\
7389  Redacted form: plmesh(x, y, z, opt)\n\
7390 \n\
7391  This function is used in example 11.\n\
7392 \n\
7393 \n\
7394 \n\
7395 SYNOPSIS:\n\
7396 \n\
7397 plmesh(x, y, z, nx, ny, opt)\n\
7398 \n\
7399 ARGUMENTS:\n\
7400 \n\
7401  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7402  which the function is evaluated.\n\
7403 \n\
7404  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7405  which the function is evaluated.\n\
7406 \n\
7407  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7408  plot. Should have dimensions of\n\
7409  nx by\n\
7410  ny.\n\
7411 \n\
7412  nx (PLINT, input) : Number of x values at which function has been\n\
7413  evaluated.\n\
7414 \n\
7415  ny (PLINT, input) : Number of y values at which function has been\n\
7416  evaluated.\n\
7417 \n\
7418  opt (PLINT, input) : Determines the way in which the surface is\n\
7419  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7420  function of x for each value of y[j] .\n\
7421  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7422  for each value of x[i] .\n\
7423  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7424  at which function is defined.\n\
7425 ";
7426 static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
7427 Magnitude colored plot surface mesh with contour\n\
7428 \n\
7429 DESCRIPTION:\n\
7430 \n\
7431  A more powerful form of plmesh: the surface mesh can be colored\n\
7432  accordingly to the current z value being plotted, a contour plot can\n\
7433  be drawn at the base XY plane, and a curtain can be drawn between the\n\
7434  plotted function border and the base XY plane.\n\
7435 \n\
7436  Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7437 \n\
7438  This function is used in example 11.\n\
7439 \n\
7440 \n\
7441 \n\
7442 SYNOPSIS:\n\
7443 \n\
7444 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7445 \n\
7446 ARGUMENTS:\n\
7447 \n\
7448  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7449  which the function is evaluated.\n\
7450 \n\
7451  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7452  which the function is evaluated.\n\
7453 \n\
7454  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7455  plot. Should have dimensions of\n\
7456  nx by\n\
7457  ny.\n\
7458 \n\
7459  nx (PLINT, input) : Number of x values at which function is\n\
7460  evaluated.\n\
7461 \n\
7462  ny (PLINT, input) : Number of y values at which function is\n\
7463  evaluated.\n\
7464 \n\
7465  opt (PLINT, input) : Determines the way in which the surface is\n\
7466  represented. To specify more than one option just add the options,\n\
7467  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7468  showing z as a function of x for each value of y[j] .\n\
7469  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7470  for each value of x[i] .\n\
7471  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7472  at which function is defined.\n\
7473  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7474  the z value being plotted. The color is used from the current\n\
7475  cmap1.\n\
7476  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7477  using parameters\n\
7478  nlevel and\n\
7479  clevel.\n\
7480  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7481  the borders of the plotted function.\n\
7482 \n\
7483 \n\
7484  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7485  levels.\n\
7486 \n\
7487  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7488 ";
7489 static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
7490 End plotting session for current stream\n\
7491 \n\
7492 DESCRIPTION:\n\
7493 \n\
7494  Ends a plotting session for the current output stream only. See\n\
7495  plsstrm for more info.\n\
7496 \n\
7497  Redacted form: plend1()\n\
7498 \n\
7499  This function is used in examples 1 and 20.\n\
7500 \n\
7501 \n\
7502 \n\
7503 SYNOPSIS:\n\
7504 \n\
7505 plend1()\n\
7506 ";
7507 static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
7508 Get y axis parameters\n\
7509 \n\
7510 DESCRIPTION:\n\
7511 \n\
7512  Identical to plgxax, except that arguments are flags for y axis. See\n\
7513  the description of plgxax for more detail.\n\
7514 \n\
7515  Redacted form: plgyax(p_digmax, p_digits)\n\
7516 \n\
7517  This function is used in example 31.\n\
7518 \n\
7519 \n\
7520 \n\
7521 SYNOPSIS:\n\
7522 \n\
7523 plgyax(p_digmax, p_digits)\n\
7524 \n\
7525 ARGUMENTS:\n\
7526 \n\
7527  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7528  number of digits for the y axis. If nonzero, the printed label\n\
7529  has been switched to a floating-point representation when the\n\
7530  number of digits exceeds this value.\n\
7531 \n\
7532  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7533  number of digits for the numeric labels (y axis) from the last\n\
7534  plot.\n\
7535 ";
7536 static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
7537 Set plot orientation\n\
7538 \n\
7539 DESCRIPTION:\n\
7540 \n\
7541  Set plot orientation parameter which is multiplied by 90 degrees to\n\
7542  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7543  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7544  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7545  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7546  (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7547  not called the default value of rot is 0.\n\
7548 \n\
7549  N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7550  probably want to change the aspect ratio to a value suitable for the\n\
7551  plot orientation using a call to plsdidev or the command-line options\n\
7552  -a or -freeaspect. For more documentation of those options see the\n\
7553  PLplot documentation. Such command-line options can be set internally\n\
7554  using plsetopt or set directly using the command line and parsed using\n\
7555  a call to plparseopts.\n\
7556 \n\
7557  Redacted form: plsdiori(rot)\n\
7558 \n\
7559  This function is not used in any examples.\n\
7560 \n\
7561 \n\
7562 \n\
7563 SYNOPSIS:\n\
7564 \n\
7565 plsdiori(rot)\n\
7566 \n\
7567 ARGUMENTS:\n\
7568 \n\
7569  rot (PLFLT, input) : Plot orientation parameter.\n\
7570 ";
7571 static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7572 Plot a histogram from unbinned data\n\
7573 \n\
7574 DESCRIPTION:\n\
7575 \n\
7576  Plots a histogram from n data points stored in the data vector. This\n\
7577  routine bins the data into nbin bins equally spaced between datmin and\n\
7578  datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7579  opt allows, among other things, the histogram either to be plotted in\n\
7580  an existing window or causes plhist to call plenv with suitable limits\n\
7581  before plotting the histogram.\n\
7582 \n\
7583  Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7584 \n\
7585  This function is used in example 5.\n\
7586 \n\
7587 \n\
7588 \n\
7589 SYNOPSIS:\n\
7590 \n\
7591 plhist(n, data, datmin, datmax, nbin, opt)\n\
7592 \n\
7593 ARGUMENTS:\n\
7594 \n\
7595  n (PLINT, input) : Number of data points.\n\
7596 \n\
7597  data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7598  n data points.\n\
7599 \n\
7600  datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7601 \n\
7602  datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7603 \n\
7604  nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7605  divide the interval xmin to xmax.\n\
7606 \n\
7607  opt (PLINT, input) : Is a combination of several flags:\n\
7608  opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7609  the histogram data, the outer bins are expanded to fill up the\n\
7610  entire x-axis, data outside the given extremes are assigned to the\n\
7611  outer bins and bins of zero height are simply drawn.\n\
7612  opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7613  to fit the histogram data, without this flag, plenv is called\n\
7614  to set the world coordinates.\n\
7615  opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7616  extremes are not taken into account. This option should\n\
7617  probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7618  properly present the data.\n\
7619  opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7620  size as the ones inside.\n\
7621  opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7622  (there is a gap for such bins).\n\
7623 ";
7624 static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
7625 End plotting session\n\
7626 \n\
7627 DESCRIPTION:\n\
7628 \n\
7629  Ends a plotting session, tidies up all the output files, switches\n\
7630  interactive devices back into text mode and frees up any memory that\n\
7631  was allocated. Must be called before end of program.\n\
7632 \n\
7633  By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7634  wait state after a call to plend or other functions which trigger the\n\
7635  end of a plot page. To avoid this, use the plspause function.\n\
7636 \n\
7637  Redacted form: plend()\n\
7638 \n\
7639  This function is used in all of the examples.\n\
7640 \n\
7641 \n\
7642 \n\
7643 SYNOPSIS:\n\
7644 \n\
7645 plend()\n\
7646 ";
7647 static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
7648 Plot shaded 3-d surface plot\n\
7649 \n\
7650 DESCRIPTION:\n\
7651 \n\
7652  Plots a three-dimensional shaded surface plot within the environment\n\
7653  set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7654  z[\n\
7655  nx][\n\
7656  ny], the point z[i][j] being the value of the function at (\n\
7657  x[i],\n\
7658  y[j]). Note that the points in vectors x and y do not need to be\n\
7659  equally spaced, but must be stored in ascending order. For further\n\
7660  details see the PLplot documentation.\n\
7661 \n\
7662  Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7663 \n\
7664  This function is not used in any examples.\n\
7665 \n\
7666 \n\
7667 \n\
7668 SYNOPSIS:\n\
7669 \n\
7670 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7671 \n\
7672 ARGUMENTS:\n\
7673 \n\
7674  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7675  which the function is evaluated.\n\
7676 \n\
7677  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7678  which the function is evaluated.\n\
7679 \n\
7680  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7681  plot. Should have dimensions of\n\
7682  nx by\n\
7683  ny.\n\
7684 \n\
7685  nx (PLINT, input) : Number of x values at which function is\n\
7686  evaluated.\n\
7687 \n\
7688  ny (PLINT, input) : Number of y values at which function is\n\
7689  evaluated.\n\
7690 \n\
7691  opt (PLINT, input) : Determines the way in which the surface is\n\
7692  represented. To specify more than one option just add the options,\n\
7693  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7694  connecting points at which function is defined.\n\
7695  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7696  using parameters\n\
7697  nlevel and\n\
7698  clevel.\n\
7699  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7700  using parameters\n\
7701  nlevel and\n\
7702  clevel.\n\
7703  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7704  the borders of the plotted function.\n\
7705  opt=MAG_COLOR : the surface is colored according to the value\n\
7706  of Z; if MAG_COLOR is not used, then the surface is colored\n\
7707  according to the intensity of the reflected light in the\n\
7708  surface from a light source whose position is set using\n\
7709  pllightsource.\n\
7710 \n\
7711 \n\
7712  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7713  levels.\n\
7714 \n\
7715  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7716 ";
7717 static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
7718 Set device-compression level\n\
7719 \n\
7720 DESCRIPTION:\n\
7721 \n\
7722  Set device-compression level. Only used for drivers that provide\n\
7723  compression. This function, if used, should be invoked before a call\n\
7724  to plinit.\n\
7725 \n\
7726  Redacted form: plscompression(compression)\n\
7727 \n\
7728  This function is used in example 31.\n\
7729 \n\
7730 \n\
7731 \n\
7732 SYNOPSIS:\n\
7733 \n\
7734 plscompression(compression)\n\
7735 \n\
7736 ARGUMENTS:\n\
7737 \n\
7738  compression (PLINT, input) : The desired compression level. This is\n\
7739  a device-dependent value. Currently only the jpeg and png devices\n\
7740  use these values. For jpeg value is the jpeg quality which should\n\
7741  normally be in the range 0-95. Higher values denote higher quality\n\
7742  and hence larger image sizes. For png values are in the range -1\n\
7743  to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7744  A value of -1 denotes the default zlib compression level. Values\n\
7745  in the range 10-99 are divided by 10 and then used as the zlib\n\
7746  compression level. Higher compression levels correspond to greater\n\
7747  compression and small file sizes at the expense of more\n\
7748  computation.\n\
7749 ";
7750 static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
7751 Get the current device-compression setting\n\
7752 \n\
7753 DESCRIPTION:\n\
7754 \n\
7755  Get the current device-compression setting. This parameter is only\n\
7756  used for drivers that provide compression.\n\
7757 \n\
7758  Redacted form: plgcompression(compression)\n\
7759 \n\
7760  This function is used in example 31.\n\
7761 \n\
7762 \n\
7763 \n\
7764 SYNOPSIS:\n\
7765 \n\
7766 plgcompression(compression)\n\
7767 \n\
7768 ARGUMENTS:\n\
7769 \n\
7770  compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7771  compression setting for the current device.\n\
7772 ";
7773 static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
7774 Advance the (sub-)page\n\
7775 \n\
7776 DESCRIPTION:\n\
7777 \n\
7778  Advances to the next subpage if sub=0, performing a page advance if\n\
7779  there are no remaining subpages on the current page. If subpages\n\
7780  aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7781  PLplot switches to the specified subpage. Note that this allows you\n\
7782  to overwrite a plot on the specified subpage; if this is not what you\n\
7783  intended, use pleop followed by plbop to first advance the page. This\n\
7784  routine is called automatically (with page=0) by plenv, but if plenv\n\
7785  is not used, pladv must be called after initializing PLplot but before\n\
7786  defining the viewport.\n\
7787 \n\
7788  Redacted form: pladv(page)\n\
7789 \n\
7790  This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7791  29, and 31.\n\
7792 \n\
7793 \n\
7794 \n\
7795 SYNOPSIS:\n\
7796 \n\
7797 pladv(page)\n\
7798 \n\
7799 ARGUMENTS:\n\
7800 \n\
7801  page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7802  in the top left corner and increasing along the rows) to which to\n\
7803  advance. Set to zero to advance to the next subpage (or to the\n\
7804  next page if subpages are not being used).\n\
7805 ";
7806 static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7807 Set parameters of contour labelling other than format of numerical label\n\
7808 \n\
7809 DESCRIPTION:\n\
7810 \n\
7811  Set parameters of contour labelling other than those handled by\n\
7812  pl_setcontlabelformat.\n\
7813 \n\
7814  Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7815 \n\
7816  This function is used in example 9.\n\
7817 \n\
7818 \n\
7819 \n\
7820 SYNOPSIS:\n\
7821 \n\
7822 pl_setcontlabelparam(offset, size, spacing, active)\n\
7823 \n\
7824 ARGUMENTS:\n\
7825 \n\
7826  offset (PLFLT, input) : Offset of label from contour line (if set\n\
7827  to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7828 \n\
7829  size (PLFLT, input) : Font height for contour labels (normalized).\n\
7830  Default value is 0.3.\n\
7831 \n\
7832  spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7833  Default value is 0.1.\n\
7834 \n\
7835  active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7836  contour labels on. Default is off (0).\n\
7837 ";
7838 static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
7839 Set family, style and weight of the current font\n\
7840 \n\
7841 DESCRIPTION:\n\
7842 \n\
7843  Sets the current font. See the PLplot documentation for more\n\
7844  information on font selection.\n\
7845 \n\
7846  Redacted form: plsfont(family, style, weight)\n\
7847 \n\
7848  This function is used in example 23.\n\
7849 \n\
7850 \n\
7851 \n\
7852 SYNOPSIS:\n\
7853 \n\
7854 plsfont(family, style, weight)\n\
7855 \n\
7856 ARGUMENTS:\n\
7857 \n\
7858  family (PLINT, input) : Font family to select for the current font.\n\
7859  The available values are given by the PL_FCI_* constants in\n\
7860  plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7861  PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7862  signifies that the font family should not be altered.\n\
7863 \n\
7864  style (PLINT, input) : Font style to select for the current font.\n\
7865  The available values are given by the PL_FCI_* constants in\n\
7866  plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7867  PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7868  should not be altered.\n\
7869 \n\
7870  weight (PLINT, input) : Font weight to select for the current font.\n\
7871  The available values are given by the PL_FCI_* constants in\n\
7872  plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7873  negative value signifies that the font weight should not be\n\
7874  altered.\n\
7875 ";
7876 static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
7877 Sets the 3D position of the light source\n\
7878 \n\
7879 DESCRIPTION:\n\
7880 \n\
7881  Sets the 3D position of the light source for use with plsurf3d and\n\
7882  plsurf3dl\n\
7883 \n\
7884  Redacted form: pllightsource(x, y, z)\n\
7885 \n\
7886  This function is used in example 8.\n\
7887 \n\
7888 \n\
7889 \n\
7890 SYNOPSIS:\n\
7891 \n\
7892 pllightsource(x, y, z)\n\
7893 \n\
7894 ARGUMENTS:\n\
7895 \n\
7896  x (PLFLT, input) : X-coordinate of the light source.\n\
7897 \n\
7898  y (PLFLT, input) : Y-coordinate of the light source.\n\
7899 \n\
7900  z (PLFLT, input) : Z-coordinate of the light source.\n\
7901 ";
7902 static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
7903 Draw a line\n\
7904 \n\
7905 DESCRIPTION:\n\
7906 \n\
7907  Draws line defined by n points in x and y.\n\
7908 \n\
7909  Redacted form: plline(x, y)\n\
7910 \n\
7911  This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
7912  25-27, and 29.\n\
7913 \n\
7914 \n\
7915 \n\
7916 SYNOPSIS:\n\
7917 \n\
7918 plline(n, x, y)\n\
7919 \n\
7920 ARGUMENTS:\n\
7921 \n\
7922  n (PLINT, input) : Number of points defining line.\n\
7923 \n\
7924  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7925  points.\n\
7926 \n\
7927  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7928  points.\n\
7929 ";
7930 static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
7931 Set pen width\n\
7932 \n\
7933 DESCRIPTION:\n\
7934 \n\
7935  Sets the pen width.\n\
7936 \n\
7937  Redacted form: plwidth(width)\n\
7938 \n\
7939  This function is used in examples 1 and 2.\n\
7940 \n\
7941 \n\
7942 \n\
7943 SYNOPSIS:\n\
7944 \n\
7945 plwidth(width)\n\
7946 \n\
7947 ARGUMENTS:\n\
7948 \n\
7949  width (PLFLT, input) : The desired pen width. If width is negative\n\
7950  or the same as the previous value no action is taken. width = 0.\n\
7951  should be interpreted as as the minimum valid pen width for the\n\
7952  device. The interpretation of positive width values is also\n\
7953  device dependent.\n\
7954 ";
7955 static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
7956 Draw linear gradient inside polygon\n\
7957 \n\
7958 DESCRIPTION:\n\
7959 \n\
7960  Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
7961  points (\n\
7962  x[i],\n\
7963  y[i]). Interpretation of the polygon is the same as for plfill. The\n\
7964  polygon coordinates and the gradient angle are all expressed in world\n\
7965  coordinates. The angle from the x axis for both the rotated\n\
7966  coordinate system and the gradient vector is specified by angle. The\n\
7967  magnitude of the gradient vector is the difference between the maximum\n\
7968  and minimum values of x for the vertices in the rotated coordinate\n\
7969  system. The origin of the gradient vector can be interpreted as being\n\
7970  anywhere on the line corresponding to the minimum x value for the\n\
7971  vertices in the rotated coordinate system. The distance along the\n\
7972  gradient vector is linearly transformed to the independent variable of\n\
7973  color map 1 which ranges from 0. at the tail of the gradient vector to\n\
7974  1. at the head of the gradient vector. What is drawn is the RGBA\n\
7975  color corresponding to the independent variable of cmap1. For more\n\
7976  information about cmap1 (see the PLplot documentation).\n\
7977 \n\
7978  Redacted form: plgradient(x,y,angle)\n\
7979 \n\
7980  This function is used in examples 25 and 30.\n\
7981 \n\
7982 \n\
7983 \n\
7984 SYNOPSIS:\n\
7985 \n\
7986 plgradient(n, x, y, angle)\n\
7987 \n\
7988 ARGUMENTS:\n\
7989 \n\
7990  n (PLINT, input) : Number of vertices in polygon.\n\
7991 \n\
7992  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7993  vertices.\n\
7994 \n\
7995  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7996  vertices.\n\
7997 \n\
7998  angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
7999  axis.\n\
8000 ";
8001 static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
8002 Flushes the output stream\n\
8003 \n\
8004 DESCRIPTION:\n\
8005 \n\
8006  Flushes the output stream. Use sparingly, if at all.\n\
8007 \n\
8008  Redacted form: plflush()\n\
8009 \n\
8010  This function is used in examples 1 and 14.\n\
8011 \n\
8012 \n\
8013 \n\
8014 SYNOPSIS:\n\
8015 \n\
8016 plflush()\n\
8017 ";
8018 static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
8019 Get plot orientation\n\
8020 \n\
8021 DESCRIPTION:\n\
8022 \n\
8023  Get plot orientation parameter which is multiplied by 90 degrees to\n\
8024  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
8025  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
8026  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
8027  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
8028  (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
8029  not been called the default value pointed to by p_rot will be 0.\n\
8030 \n\
8031  Redacted form: plgdiori(p_rot)\n\
8032 \n\
8033  This function is not used in any examples.\n\
8034 \n\
8035 \n\
8036 \n\
8037 SYNOPSIS:\n\
8038 \n\
8039 plgdiori(p_rot)\n\
8040 \n\
8041 ARGUMENTS:\n\
8042 \n\
8043  p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
8044  parameter.\n\
8045 ";
8046 static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
8047 Set x axis parameters\n\
8048 \n\
8049 DESCRIPTION:\n\
8050 \n\
8051  Sets values of the digmax and digits flags for the x axis. See the\n\
8052  PLplot documentation for more information.\n\
8053 \n\
8054  Redacted form: plsxax(digmax, digits)\n\
8055 \n\
8056  This function is used in example 31.\n\
8057 \n\
8058 \n\
8059 \n\
8060 SYNOPSIS:\n\
8061 \n\
8062 plsxax(digmax, digits)\n\
8063 \n\
8064 ARGUMENTS:\n\
8065 \n\
8066  digmax (PLINT, input) : Variable to set the maximum number of\n\
8067  digits for the x axis. If nonzero, the printed label will be\n\
8068  switched to a floating-point representation when the number of\n\
8069  digits exceeds digmax.\n\
8070 \n\
8071  digits (PLINT, input) : Field digits value. Currently, changing\n\
8072  its value here has no effect since it is set only by plbox or\n\
8073  plbox3. However, the user may obtain its value after a call to\n\
8074  either of these functions by calling plgxax.\n\
8075 ";
8076 static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
8077 Get viewport limits in world coordinates\n\
8078 \n\
8079 DESCRIPTION:\n\
8080 \n\
8081  Get viewport limits in world coordinates.\n\
8082 \n\
8083  Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8084 \n\
8085 \n\
8086  This function is used in example 31.\n\
8087 \n\
8088 \n\
8089 \n\
8090 SYNOPSIS:\n\
8091 \n\
8092 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8093 \n\
8094 ARGUMENTS:\n\
8095 \n\
8096  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8097  viewport limit of the world coordinate in x.\n\
8098 \n\
8099  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8100  viewport limit of the world coordinate in x.\n\
8101 \n\
8102  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8103  viewport limit of the world coordinate in y.\n\
8104 \n\
8105  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8106  viewport limit of the world coordinate in y.\n\
8107 ";
8108 static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
8109 Shade regions on the basis of value\n\
8110 \n\
8111 DESCRIPTION:\n\
8112 \n\
8113  Shade regions on the basis of value. This is the high-level routine\n\
8114  for making continuous color shaded plots with cmap1 while plshade\n\
8115  should be used to plot individual shaded regions using either cmap0 or\n\
8116  cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
8117  our supported languages.\n\
8118 \n\
8119  Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
8120  clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
8121  pltr_data)\n\
8122 \n\
8123 \n\
8124  This function is used in examples 16, 21, and 22.\n\
8125 \n\
8126 \n\
8127 \n\
8128 SYNOPSIS:\n\
8129 \n\
8130 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
8131 \n\
8132 ARGUMENTS:\n\
8133 \n\
8134  a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8135  plot. Should have dimensions of\n\
8136  nx by\n\
8137  ny.\n\
8138 \n\
8139  nx (PLINT, input) : First dimension of matrix \"a\".\n\
8140 \n\
8141  ny (PLINT, input) : Second dimension of matrix \"a\".\n\
8142 \n\
8143  defined (PLDEFINED_callback, input) : Callback function specifying\n\
8144  the region that should be plotted in the shade plot. This\n\
8145  function accepts x and y coordinates as input arguments and must\n\
8146  return 1 if the point is to be included in the shade plot and 0\n\
8147  otherwise. If you want to plot the entire shade plot (the usual\n\
8148  case), this argument should be set to NULL.\n\
8149 \n\
8150  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8151  pltr below for how these arguments are used (only for the special case\n\
8152  when the callback function\n\
8153  pltr is not supplied).\n\
8154 \n\
8155  clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
8156  corresponding to the edges of each shaded region that will be\n\
8157  plotted by this function. To work properly the levels should be\n\
8158  monotonic.\n\
8159 \n\
8160  nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
8161  of shade edge values in clevel).\n\
8162 \n\
8163  fill_width (PLFLT, input) : Defines the line width used by the fill\n\
8164  pattern.\n\
8165 \n\
8166  cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
8167  contours defining edges of shaded regions. The pen color is only\n\
8168  temporary set for the contour drawing. Set this value to zero or\n\
8169  less if no shade edge contours are wanted.\n\
8170 \n\
8171  cont_width (PLFLT, input) : Defines line width used for contours\n\
8172  defining edges of shaded regions. This value may not be honored\n\
8173  by all drivers. The pen width is only temporary set for the\n\
8174  contour drawing. Set this value to zero or less if no shade edge\n\
8175  contours are wanted.\n\
8176 \n\
8177  fill (PLFILL_callback, input) : Callback routine used to fill the\n\
8178  region. Use plfill for this purpose.\n\
8179 \n\
8180  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8181  map to rectangles after coordinate transformation with pltrl.\n\
8182  Otherwise, set rectangular to false. If rectangular is set to\n\
8183  true, plshade tries to save time by filling large rectangles.\n\
8184  This optimization fails if the coordinate transformation distorts\n\
8185  the shape of rectangles. For example a plot in polar coordinates\n\
8186  has to have rectangular set to false.\n\
8187 \n\
8188  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8189  defines the transformation between the zero-based indices of the\n\
8190  matrix a and world coordinates. If\n\
8191  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8192  indices of a are mapped to the range\n\
8193  xmin through\n\
8194  xmax and the y indices of a are mapped to the range\n\
8195  ymin through\n\
8196  ymax.For the C case, transformation functions are provided in the\n\
8197  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8198  pltr2 for arbitrary mappings respectively defined by vectors and\n\
8199  matrices. In addition, C callback routines for the transformation\n\
8200  can be supplied by the user such as the mypltr function in\n\
8201  examples/c/x09c.c which provides a general linear transformation\n\
8202  between index coordinates and world coordinates.For languages\n\
8203  other than C you should consult the PLplot documentation for the\n\
8204  details concerning how PLTRANSFORM_callback arguments are\n\
8205  interfaced. However, in general, a particular pattern of\n\
8206  callback-associated arguments such as a tr vector with 6 elements;\n\
8207  xg and yg vectors; or xg and yg matrices are respectively\n\
8208  interfaced to a linear-transformation routine similar to the above\n\
8209  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8210  sophisticated bindings (see, e.g., the PLplot documentation)\n\
8211  support native language callbacks for handling index to\n\
8212  world-coordinate transformations. Examples of these various\n\
8213  approaches are given in examples/<language>x09*,\n\
8214  examples/<language>x16*, examples/<language>x20*,\n\
8215  examples/<language>x21*, and examples/<language>x22*, for all our\n\
8216  supported languages.\n\
8217 \n\
8218  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8219  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8220  externally supplied.\n\
8221 ";
8222 static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
8223 Plot color bar for image, shade or gradient plots\n\
8224 \n\
8225 DESCRIPTION:\n\
8226 \n\
8227  Routine for creating a continuous color bar for image, shade, or\n\
8228  gradient plots. (See pllegend for similar functionality for creating\n\
8229  legends with discrete elements). The arguments of plcolorbar provide\n\
8230  control over the location and size of the color bar as well as the\n\
8231  location and characteristics of the elements (most of which are\n\
8232  optional) within that color bar. The resulting color bar is clipped\n\
8233  at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
8234  system used for some of the parameters is defined in the documentation\n\
8235  of the position parameter.)\n\
8236 \n\
8237  Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
8238  position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
8239  low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
8240  labels, axis_opts, ticks, sub_ticks, values)\n\
8241 \n\
8242  This function is used in examples 16 and 33.\n\
8243 \n\
8244 \n\
8245 \n\
8246 SYNOPSIS:\n\
8247 \n\
8248 plcolorbar(p_colorbar_width, p_colorbar_height, opt, position, x, y, x_length, y_length, bg_color, bb_color, bb_style, low_cap_color, high_cap_color, cont_color, cont_width, n_labels, label_opts, labels, naxes, axis_opts, ticks, sub_ticks, n_values, values)\n\
8249 \n\
8250 ARGUMENTS:\n\
8251 \n\
8252  p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8253  labelled and decorated color bar width in adopted coordinates.\n\
8254 \n\
8255  p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8256  labelled and decorated color bar height in adopted coordinates.\n\
8257 \n\
8258  opt (PLINT, input) : opt contains bits controlling the overall\n\
8259  color bar. The orientation (direction of the maximum value) of\n\
8260  the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
8261  PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
8262  specified, the default orientation is toward the top if the\n\
8263  colorbar is placed on the left or right of the viewport or toward\n\
8264  the right if the colorbar is placed on the top or bottom of the\n\
8265  viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
8266  (semitransparent) background for the color bar. If the\n\
8267  PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8268  color bar. The type of color bar must be specified with one of\n\
8269  PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
8270  more than one of those bits is set only the first one in the above\n\
8271  list is honored. The position of the (optional) label/title can be\n\
8272  specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
8273  PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
8274  will be drawn. If more than one of this list of bits is specified,\n\
8275  only the first one on the list is honored. End-caps for the color\n\
8276  bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
8277  If a particular color bar cap option is not specified then no cap\n\
8278  will be drawn for that end. As a special case for\n\
8279  PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
8280  specified. If this option is provided then any tick marks and tick\n\
8281  labels will be placed at the breaks between shaded segments. TODO:\n\
8282  This should be expanded to support custom placement of tick marks\n\
8283  and tick labels at custom value locations for any color bar type.\n\
8284 \n\
8285  position (PLINT, input) : position contains bits which control the\n\
8286  overall position of the color bar and the definition of the\n\
8287  adopted coordinates used for positions just like what is done for\n\
8288  the position argument for pllegend. However, note that the\n\
8289  defaults for the position bits (see below) are different than the\n\
8290  pllegend case. The combination of the PL_POSITION_LEFT,\n\
8291  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8292  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8293  the 16 possible standard positions (the 4 corners and centers of\n\
8294  the 4 sides for both the inside and outside cases) of the color\n\
8295  bar relative to the adopted coordinate system. The corner\n\
8296  positions are specified by the appropriate combination of two of\n\
8297  the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8298  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8299  value of one of those bits. The adopted coordinates are\n\
8300  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8301  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8302  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8303  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8304  then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
8305  PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
8306  PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
8307  PL_POSITION_VIEWPORT.\n\
8308 \n\
8309  x (PLFLT, input) : X offset of the color bar position in adopted\n\
8310  coordinates from the specified standard position of the color bar.\n\
8311  For positive x, the direction of motion away from the standard\n\
8312  position is inward/outward from the standard corner positions or\n\
8313  standard left or right positions if the\n\
8314  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8315  For the standard top or bottom positions, the direction of motion\n\
8316  is toward positive X.\n\
8317 \n\
8318  y (PLFLT, input) : Y offset of the color bar position in adopted\n\
8319  coordinates from the specified standard position of the color bar.\n\
8320  For positive y, the direction of motion away from the standard\n\
8321  position is inward/outward from the standard corner positions or\n\
8322  standard top or bottom positions if the\n\
8323  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8324  For the standard left or right positions, the direction of motion\n\
8325  is toward positive Y.\n\
8326 \n\
8327  x_length (PLFLT, input) : Length of the body of the color bar in\n\
8328  the X direction in adopted coordinates.\n\
8329 \n\
8330  y_length (PLFLT, input) : Length of the body of the color bar in\n\
8331  the Y direction in adopted coordinates.\n\
8332 \n\
8333  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8334  color bar (PL_COLORBAR_BACKGROUND).\n\
8335 \n\
8336  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8337  for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8338 \n\
8339  bb_style (PLINT, input) : The pllsty style number for the\n\
8340  bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8341 \n\
8342  low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8343  bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8344 \n\
8345  high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8346  color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8347 \n\
8348  cont_color (PLINT, input) : The cmap0 contour color for\n\
8349  PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8350  it will be interpreted according to the design of plshades.\n\
8351 \n\
8352  cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8353  plots. This is passed directly to plshades, so it will be\n\
8354  interpreted according to the design of plshades.\n\
8355 \n\
8356  n_labels (PLINT, input) : Number of labels to place around the\n\
8357  color bar.\n\
8358 \n\
8359  label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8360  n_labels labels.\n\
8361 \n\
8362  labels (PLCHAR_MATRIX, input) : A vector of\n\
8363  n_labels UTF-8 character strings containing the labels for the color\n\
8364  bar. Ignored if no label position is specified with one of the\n\
8365  PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8366  PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8367  corresponding label_opts field.\n\
8368 \n\
8369  n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8370  value must be greater than 0. It is typically 1 (numerical axis\n\
8371  labels are provided for one of the long edges of the color bar),\n\
8372  but it can be larger if multiple numerical axis labels for the\n\
8373  long edges of the color bar are desired.\n\
8374 \n\
8375  axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8376  n_axes ascii character strings containing options (interpreted as for\n\
8377  plbox) for the color bar\'s axis definitions.\n\
8378 \n\
8379  ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8380  spacing of the major tick marks (interpreted as for plbox) for the\n\
8381  color bar\'s axis definitions.\n\
8382 \n\
8383  sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8384  number of subticks (interpreted as for plbox) for the color bar\'s\n\
8385  axis definitions.\n\
8386 \n\
8387  n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8388  elements in each of the n_axes rows of the values matrix.\n\
8389 \n\
8390  values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8391  values for the data range represented by the color bar. For a row\n\
8392  index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8393  elements in the row is specified by n_values[i_axis]. For\n\
8394  PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8395  is 2, and the corresponding row elements of the values matrix are\n\
8396  the minimum and maximum value represented by the colorbar. For\n\
8397  PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8398  of the values matrix is interpreted the same as the nlevel and\n\
8399  clevel arguments of plshades.\n\
8400 ";
8401 static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
8402 Get current subpage parameters\n\
8403 \n\
8404 DESCRIPTION:\n\
8405 \n\
8406  Gets the size of the current subpage in millimeters measured from the\n\
8407  bottom left hand corner of the output device page or screen. Can be\n\
8408  used in conjunction with plsvpa for setting the size of a viewport in\n\
8409  absolute coordinates (millimeters).\n\
8410 \n\
8411  Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8412 \n\
8413  This function is used in example 23.\n\
8414 \n\
8415 \n\
8416 \n\
8417 SYNOPSIS:\n\
8418 \n\
8419 plgspa(xmin, xmax, ymin, ymax)\n\
8420 \n\
8421 ARGUMENTS:\n\
8422 \n\
8423  xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8424  the left hand edge of the subpage in millimeters.\n\
8425 \n\
8426  xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8427  the right hand edge of the subpage in millimeters.\n\
8428 \n\
8429  ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8430  the bottom edge of the subpage in millimeters.\n\
8431 \n\
8432  ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8433  the top edge of the subpage in millimeters.\n\
8434 ";
8435 static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
8436 Shade individual region on the basis of value\n\
8437 \n\
8438 DESCRIPTION:\n\
8439 \n\
8440  Shade individual region on the basis of value. Use plshades if you\n\
8441  want to shade a number of contiguous regions using continuous colors.\n\
8442  In particular the edge contours are treated properly in plshades. If\n\
8443  you attempt to do contiguous regions with plshade the contours at the\n\
8444  edge of the shade are partially obliterated by subsequent plots of\n\
8445  contiguous shaded regions.\n\
8446 \n\
8447  Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8448  shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8449  min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8450 \n\
8451 \n\
8452  This function is used in example 15.\n\
8453 \n\
8454 \n\
8455 \n\
8456 SYNOPSIS:\n\
8457 \n\
8458 plshade(a, nx, ny, defined, xmin, xmax, ymin, ymax, shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color, min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8459 \n\
8460 ARGUMENTS:\n\
8461 \n\
8462  a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8463  plot. Should have dimensions of\n\
8464  nx by\n\
8465  ny.\n\
8466 \n\
8467  nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8468 \n\
8469  ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8470 \n\
8471  defined (PLDEFINED_callback, input) : Callback function specifying\n\
8472  the region that should be plotted in the shade plot. This\n\
8473  function accepts x and y coordinates as input arguments and must\n\
8474  return 1 if the point is to be included in the shade plot and 0\n\
8475  otherwise. If you want to plot the entire shade plot (the usual\n\
8476  case), this argument should be set to NULL.\n\
8477 \n\
8478  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8479  pltr below for how these arguments are used (only for the special case\n\
8480  when the callback function\n\
8481  pltr is not supplied).\n\
8482 \n\
8483  shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8484  be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8485 \n\
8486  shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8487  be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8488 \n\
8489  sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8490  sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8491  then sh_color is interpreted as a cmap1 argument in the range\n\
8492  (0.0-1.0).\n\
8493 \n\
8494  sh_color (PLFLT, input) : Defines color map index with integer\n\
8495  value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8496 \n\
8497  sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8498 \n\
8499  min_color (PLINT, input) : Defines pen color, width used by the\n\
8500  boundary of shaded region. The min values are used for the\n\
8501  shade_min boundary, and the max values are used on the shade_max\n\
8502  boundary. Set color and width to zero for no plotted boundaries.\n\
8503 \n\
8504  min_width (PLFLT, input) : Defines pen color, width used by the\n\
8505  boundary of shaded region. The min values are used for the\n\
8506  shade_min boundary, and the max values are used on the shade_max\n\
8507  boundary. Set color and width to zero for no plotted boundaries.\n\
8508 \n\
8509  max_color (PLINT, input) : Defines pen color, width used by the\n\
8510  boundary of shaded region. The min values are used for the\n\
8511  shade_min boundary, and the max values are used on the shade_max\n\
8512  boundary. Set color and width to zero for no plotted boundaries.\n\
8513 \n\
8514  max_width (PLFLT, input) : Defines pen color, width used by the\n\
8515  boundary of shaded region. The min values are used for the\n\
8516  shade_min boundary, and the max values are used on the shade_max\n\
8517  boundary. Set color and width to zero for no plotted boundaries.\n\
8518 \n\
8519  fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8520  Use plfill. Future version of PLplot may have other fill\n\
8521  routines.\n\
8522 \n\
8523  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8524  map to rectangles after coordinate transformation with pltrl.\n\
8525  Otherwise, set rectangular to false. If rectangular is set to\n\
8526  true, plshade tries to save time by filling large rectangles.\n\
8527  This optimization fails if the coordinate transformation distorts\n\
8528  the shape of rectangles. For example a plot in polar coordinates\n\
8529  has to have rectangular set to false.\n\
8530 \n\
8531  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8532  defines the transformation between the zero-based indices of the\n\
8533  matrix a and world coordinates. If\n\
8534  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8535  indices of a are mapped to the range\n\
8536  xmin through\n\
8537  xmax and the y indices of a are mapped to the range\n\
8538  ymin through\n\
8539  ymax.For the C case, transformation functions are provided in the\n\
8540  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8541  pltr2 for arbitrary mappings respectively defined by vectors and\n\
8542  matrices. In addition, C callback routines for the transformation\n\
8543  can be supplied by the user such as the mypltr function in\n\
8544  examples/c/x09c.c which provides a general linear transformation\n\
8545  between index coordinates and world coordinates.For languages\n\
8546  other than C you should consult the PLplot documentation for the\n\
8547  details concerning how PLTRANSFORM_callback arguments are\n\
8548  interfaced. However, in general, a particular pattern of\n\
8549  callback-associated arguments such as a tr vector with 6 elements;\n\
8550  xg and yg vectors; or xg and yg matrices are respectively\n\
8551  interfaced to a linear-transformation routine similar to the above\n\
8552  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8553  sophisticated bindings (see, e.g., the PLplot documentation)\n\
8554  support native language callbacks for handling index to\n\
8555  world-coordinate transformations. Examples of these various\n\
8556  approaches are given in examples/<language>x09*,\n\
8557  examples/<language>x16*, examples/<language>x20*,\n\
8558  examples/<language>x21*, and examples/<language>x22*, for all our\n\
8559  supported languages.\n\
8560 \n\
8561  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8562  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8563  externally supplied.\n\
8564 ";
8565 static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
8566 Calculate world coordinates and corresponding window index from relative device coordinates\n\
8567 \n\
8568 DESCRIPTION:\n\
8569 \n\
8570  Calculate world coordinates, wx and wy, and corresponding window index\n\
8571  from relative device coordinates, rx and ry.\n\
8572 \n\
8573  Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8574 \n\
8575 \n\
8576  This function is used in example 31.\n\
8577 \n\
8578 \n\
8579 \n\
8580 SYNOPSIS:\n\
8581 \n\
8582 plcalc_world(rx, ry, wx, wy, window)\n\
8583 \n\
8584 ARGUMENTS:\n\
8585 \n\
8586  rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8587  the x coordinate.\n\
8588 \n\
8589  ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8590  the y coordinate.\n\
8591 \n\
8592  wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8593  coordinate corresponding to the relative device coordinates rx and\n\
8594  ry.\n\
8595 \n\
8596  wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8597  coordinate corresponding to the relative device coordinates rx and\n\
8598  ry.\n\
8599 \n\
8600  window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8601  defined window index that corresponds to the input relative device\n\
8602  coordinates (and the returned world coordinates). To give some\n\
8603  background on the window index, for each page the initial window\n\
8604  index is set to zero, and each time plwind is called within the\n\
8605  page, world and device coordinates are stored for the window and\n\
8606  the window index is incremented. Thus, for a simple page layout\n\
8607  with non-overlapping viewports and one window per viewport, window\n\
8608  corresponds to the viewport index (in the order which the\n\
8609  viewport/windows were created) of the only viewport/window\n\
8610  corresponding to rx and ry. However, for more complicated layouts\n\
8611  with potentially overlapping viewports and possibly more than one\n\
8612  window (set of world coordinates) per viewport, window and the\n\
8613  corresponding output world coordinates corresponds to the last\n\
8614  window created that fulfills the criterion that the relative\n\
8615  device coordinates are inside it. Finally, in all cases where the\n\
8616  input relative device coordinates are not inside any\n\
8617  viewport/window, then the returned value of the last defined\n\
8618  window index is set to -1.\n\
8619 ";
8620 static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
8621 Draw a box with axes, etc, in 3-d\n\
8622 \n\
8623 DESCRIPTION:\n\
8624 \n\
8625  Draws axes, numeric and text labels for a three-dimensional surface\n\
8626  plot. For a more complete description of three-dimensional plotting\n\
8627  see the PLplot documentation.\n\
8628 \n\
8629  Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8630  ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8631 \n\
8632 \n\
8633  This function is used in examples 8, 11, 18, and 21.\n\
8634 \n\
8635 \n\
8636 \n\
8637 SYNOPSIS:\n\
8638 \n\
8639 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8640 \n\
8641 ARGUMENTS:\n\
8642 \n\
8643  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8644  options for the x axis. The string can include any combination of\n\
8645  the following letters (upper or lower case) in any order: b: Draws\n\
8646  axis at base, at height z=\n\
8647  zmin where zmin is defined by call to plw3d. This character must be\n\
8648  specified in order to use any of the other options.\n\
8649  d: Plot labels as date / time. Values are assumed to be\n\
8650  seconds since the epoch (as used by gmtime).\n\
8651  f: Always use fixed point numeric labels.\n\
8652  i: Inverts tick marks, so they are drawn downwards, rather\n\
8653  than upwards.\n\
8654  l: Labels axis logarithmically. This only affects the labels,\n\
8655  not the data, and so it is necessary to compute the logarithms\n\
8656  of data points before passing them to any of the drawing\n\
8657  routines.\n\
8658  n: Writes numeric labels at major tick intervals.\n\
8659  o: Use custom labelling function to generate axis label text.\n\
8660  The custom labelling function can be defined with the\n\
8661  plslabelfunc command.\n\
8662  s: Enables subticks between major ticks, only valid if t is\n\
8663  also specified.\n\
8664  t: Draws major ticks.\n\
8665  u: If this is specified, the text label for the axis is\n\
8666  written under the axis.\n\
8667 \n\
8668 \n\
8669  xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8670  the text label for the x axis. It is only drawn if u is in the\n\
8671  xopt string.\n\
8672 \n\
8673  xtick (PLFLT, input) : World coordinate interval between major\n\
8674  ticks on the x axis. If it is set to zero, PLplot automatically\n\
8675  generates a suitable tick interval.\n\
8676 \n\
8677  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8678  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8679  generates a suitable minor tick interval.\n\
8680 \n\
8681  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8682  options for the y axis. The string is interpreted in the same way\n\
8683  as xopt.\n\
8684 \n\
8685  ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8686  the text label for the y axis. It is only drawn if u is in the\n\
8687  yopt string.\n\
8688 \n\
8689  ytick (PLFLT, input) : World coordinate interval between major\n\
8690  ticks on the y axis. If it is set to zero, PLplot automatically\n\
8691  generates a suitable tick interval.\n\
8692 \n\
8693  nysub (PLINT, input) : Number of subintervals between major y axis\n\
8694  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8695  generates a suitable minor tick interval.\n\
8696 \n\
8697  zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8698  options for the z axis. The string can include any combination of\n\
8699  the following letters (upper or lower case) in any order: b: Draws\n\
8700  z axis to the left of the surface plot.\n\
8701  c: Draws z axis to the right of the surface plot.\n\
8702  d: Draws grid lines parallel to the x-y plane behind the\n\
8703  figure. These lines are not drawn until after plot3d or\n\
8704  plmesh are called because of the need for hidden line removal.\n\
8705  e: Plot labels as date / time. Values are assumed to be\n\
8706  seconds since the epoch (as used by gmtime). Note this\n\
8707  suboption is interpreted the same as the d suboption for xopt\n\
8708  and yopt, but it has to be identified as e for zopt since d\n\
8709  has already been used for the different purpose above.\n\
8710  f: Always use fixed point numeric labels.\n\
8711  i: Inverts tick marks, so they are drawn away from the center.\n\
8712  l: Labels axis logarithmically. This only affects the labels,\n\
8713  not the data, and so it is necessary to compute the logarithms\n\
8714  of data points before passing them to any of the drawing\n\
8715  routines.\n\
8716  m: Writes numeric labels at major tick intervals on the\n\
8717  right-hand z axis.\n\
8718  n: Writes numeric labels at major tick intervals on the\n\
8719  left-hand z axis.\n\
8720  o: Use custom labelling function to generate axis label text.\n\
8721  The custom labelling function can be defined with the\n\
8722  plslabelfunc command.\n\
8723  s: Enables subticks between major ticks, only valid if t is\n\
8724  also specified.\n\
8725  t: Draws major ticks.\n\
8726  u: If this is specified, the text label is written beside the\n\
8727  left-hand axis.\n\
8728  v: If this is specified, the text label is written beside the\n\
8729  right-hand axis.\n\
8730 \n\
8731 \n\
8732  zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8733  the text label for the z axis. It is only drawn if u or v are in\n\
8734  the zopt string.\n\
8735 \n\
8736  ztick (PLFLT, input) : World coordinate interval between major\n\
8737  ticks on the z axis. If it is set to zero, PLplot automatically\n\
8738  generates a suitable tick interval.\n\
8739 \n\
8740  nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8741  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8742  generates a suitable minor tick interval.\n\
8743 ";
8744 static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
8745 Get character default height and current (scaled) height\n\
8746 \n\
8747 DESCRIPTION:\n\
8748 \n\
8749  Get character default height and current (scaled) height.\n\
8750 \n\
8751  Redacted form: plgchr(p_def, p_ht)\n\
8752 \n\
8753  This function is used in example 23.\n\
8754 \n\
8755 \n\
8756 \n\
8757 SYNOPSIS:\n\
8758 \n\
8759 plgchr(p_def, p_ht)\n\
8760 \n\
8761 ARGUMENTS:\n\
8762 \n\
8763  p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8764  character height (mm).\n\
8765 \n\
8766  p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8767  character height (mm).\n\
8768 ";
8769 static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
8770 Set the escape character for text strings\n\
8771 \n\
8772 DESCRIPTION:\n\
8773 \n\
8774  Set the escape character for text strings. From C (in contrast to\n\
8775  Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
8776  characters are allowed to prevent the user from shooting himself in\n\
8777  the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
8778  use of backslash as a character escape). Here are the allowed escape\n\
8779  characters and their corresponding decimal ASCII values: !, ASCII 33\n\
8780  #, ASCII 35\n\
8781  $, ASCII 36\n\
8782  %, ASCII 37\n\
8783  &, ASCII 38\n\
8784  *, ASCII 42\n\
8785  @, ASCII 64\n\
8786  ^, ASCII 94\n\
8787  ~, ASCII 126\n\
8788 \n\
8789 \n\
8790  Redacted form: General: plsesc(esc)\n\
8791 \n\
8792 \n\
8793  This function is used in example 29.\n\
8794 \n\
8795 \n\
8796 \n\
8797 SYNOPSIS:\n\
8798 \n\
8799 plsesc(esc)\n\
8800 \n\
8801 ARGUMENTS:\n\
8802 \n\
8803  esc (char, input) : Escape character.\n\
8804 ";
8805 static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
8806 Draw a line between two points, accounting for coordinate transforms\n\
8807 \n\
8808 DESCRIPTION:\n\
8809 \n\
8810  Joins the point (\n\
8811  x1,\n\
8812  y1) to (\n\
8813  x2,\n\
8814  y2) . If a global coordinate transform is defined then the line is\n\
8815  broken in to n segments to approximate the path. If no transform is\n\
8816  defined then this simply acts like a call to pljoin.\n\
8817 \n\
8818  Redacted form: plpath(n,x1,y1,x2,y2)\n\
8819 \n\
8820  This function is used in example 22.\n\
8821 \n\
8822 \n\
8823 \n\
8824 SYNOPSIS:\n\
8825 \n\
8826 plpath(n, x1, y1, x2, y2)\n\
8827 \n\
8828 ARGUMENTS:\n\
8829 \n\
8830  n (PLINT, input) : number of points to use to approximate the path.\n\
8831 \n\
8832  x1 (PLFLT, input) : x coordinate of first point.\n\
8833 \n\
8834  y1 (PLFLT, input) : y coordinate of first point.\n\
8835 \n\
8836  x2 (PLFLT, input) : x coordinate of second point.\n\
8837 \n\
8838  y2 (PLFLT, input) : y coordinate of second point.\n\
8839 ";
8840 static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
8841 Set up standard window and draw box\n\
8842 \n\
8843 DESCRIPTION:\n\
8844 \n\
8845  Sets up plotter environment for simple graphs by calling pladv and\n\
8846  setting up viewport and window to sensible default values. plenv\n\
8847  leaves a standard margin (left-hand margin of eight character heights,\n\
8848  and a margin around the other three sides of five character heights)\n\
8849  around most graphs for axis labels and a title. When these defaults\n\
8850  are not suitable, use the individual routines plvpas, plvpor, or\n\
8851  plvasp for setting up the viewport, plwind for defining the window,\n\
8852  and plbox for drawing the box.\n\
8853 \n\
8854  Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8855 \n\
8856  This function is used in example 1,3,9,13,14,19-22,29.\n\
8857 \n\
8858 \n\
8859 \n\
8860 SYNOPSIS:\n\
8861 \n\
8862 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8863 \n\
8864 ARGUMENTS:\n\
8865 \n\
8866  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8867  world coordinates).\n\
8868 \n\
8869  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8870  world coordinates).\n\
8871 \n\
8872  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8873  coordinates).\n\
8874 \n\
8875  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8876  coordinates).\n\
8877 \n\
8878  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8879  scales will not be set, the user must set up the scale before\n\
8880  calling plenv using plsvpa, plvasp or other.\n\
8881  0: the x and y axes are scaled independently to use as much of\n\
8882  the screen as possible.\n\
8883  1: the scales of the x and y axes are made equal.\n\
8884  2: the axis of the x and y axes are made equal, and the plot\n\
8885  box will be square.\n\
8886 \n\
8887 \n\
8888  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8889  -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
8890  -1: draw box only.\n\
8891  0: draw box, ticks, and numeric tick labels.\n\
8892  1: also draw coordinate axes at x=0 and y=0.\n\
8893  2: also draw a grid at major tick positions in both\n\
8894  coordinates.\n\
8895  3: also draw a grid at minor tick positions in both\n\
8896  coordinates.\n\
8897  10: same as 0 except logarithmic x tick marks. (The x data\n\
8898  have to be converted to logarithms separately.)\n\
8899  11: same as 1 except logarithmic x tick marks. (The x data\n\
8900  have to be converted to logarithms separately.)\n\
8901  12: same as 2 except logarithmic x tick marks. (The x data\n\
8902  have to be converted to logarithms separately.)\n\
8903  13: same as 3 except logarithmic x tick marks. (The x data\n\
8904  have to be converted to logarithms separately.)\n\
8905  20: same as 0 except logarithmic y tick marks. (The y data\n\
8906  have to be converted to logarithms separately.)\n\
8907  21: same as 1 except logarithmic y tick marks. (The y data\n\
8908  have to be converted to logarithms separately.)\n\
8909  22: same as 2 except logarithmic y tick marks. (The y data\n\
8910  have to be converted to logarithms separately.)\n\
8911  23: same as 3 except logarithmic y tick marks. (The y data\n\
8912  have to be converted to logarithms separately.)\n\
8913  30: same as 0 except logarithmic x and y tick marks. (The x\n\
8914  and y data have to be converted to logarithms separately.)\n\
8915  31: same as 1 except logarithmic x and y tick marks. (The x\n\
8916  and y data have to be converted to logarithms separately.)\n\
8917  32: same as 2 except logarithmic x and y tick marks. (The x\n\
8918  and y data have to be converted to logarithms separately.)\n\
8919  33: same as 3 except logarithmic x and y tick marks. (The x\n\
8920  and y data have to be converted to logarithms separately.)\n\
8921  40: same as 0 except date / time x labels.\n\
8922  41: same as 1 except date / time x labels.\n\
8923  42: same as 2 except date / time x labels.\n\
8924  43: same as 3 except date / time x labels.\n\
8925  50: same as 0 except date / time y labels.\n\
8926  51: same as 1 except date / time y labels.\n\
8927  52: same as 2 except date / time y labels.\n\
8928  53: same as 3 except date / time y labels.\n\
8929  60: same as 0 except date / time x and y labels.\n\
8930  61: same as 1 except date / time x and y labels.\n\
8931  62: same as 2 except date / time x and y labels.\n\
8932  63: same as 3 except date / time x and y labels.\n\
8933  70: same as 0 except custom x and y labels.\n\
8934  71: same as 1 except custom x and y labels.\n\
8935  72: same as 2 except custom x and y labels.\n\
8936  73: same as 3 except custom x and y labels.\n\
8937 ";
8938 static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
8939 Grid data from irregularly sampled data\n\
8940 \n\
8941 DESCRIPTION:\n\
8942 \n\
8943  Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
8944  require data organized as a grid, i.e., with x sample point values\n\
8945  independent of y coordinate and vice versa. This function takes\n\
8946  irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
8947  vectors; reads the desired grid location from the input vectors\n\
8948  xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
8949  grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
8950  interpolate the data to the grid is specified with the argument type\n\
8951  which can have one parameter specified in argument data.\n\
8952 \n\
8953  Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8954  Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8955 \n\
8956 \n\
8957  This function is used in example 21.\n\
8958 \n\
8959 \n\
8960 \n\
8961 SYNOPSIS:\n\
8962 \n\
8963 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8964 \n\
8965 ARGUMENTS:\n\
8966 \n\
8967  x (PLFLT_VECTOR, input) : The input x vector.\n\
8968 \n\
8969  y (PLFLT_VECTOR, input) : The input y vector.\n\
8970 \n\
8971  z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
8972  y[i], z[i] represents one data sample coordinate.\n\
8973 \n\
8974  npts (PLINT, input) : The number of data samples in the x, y and z\n\
8975  vectors.\n\
8976 \n\
8977  xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8978  in the x direction. Usually xg has nptsx equally spaced values\n\
8979  from the minimum to the maximum values of the x input vector.\n\
8980 \n\
8981  nptsx (PLINT, input) : The number of points in the xg vector.\n\
8982 \n\
8983  yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8984  in the y direction. Similar to the xg parameter.\n\
8985 \n\
8986  nptsy (PLINT, input) : The number of points in the yg vector.\n\
8987 \n\
8988  zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
8989  where data lies in the grid specified by xg and yg. Therefore the\n\
8990  zg matrix must be dimensioned\n\
8991  nptsx by\n\
8992  nptsy.\n\
8993 \n\
8994  type (PLINT, input) : The type of grid interpolation algorithm to\n\
8995  use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
8996  GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
8997  GRID_NNI: Natural Neighbors Interpolation\n\
8998  GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
8999  GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
9000  GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
9001  Weighted\n\
9002  For details of the algorithms read the source file plgridd.c.\n\
9003 \n\
9004  data (PLFLT, input) : Some gridding algorithms require extra data,\n\
9005  which can be specified through this argument. Currently, for\n\
9006  algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
9007  use, the lower the value, the noisier (more local) the\n\
9008  approximation is.\n\
9009  GRID_NNLI, data specifies what a thin triangle is, in the\n\
9010  range [1. .. 2.]. High values enable the usage of very thin\n\
9011  triangles for interpolation, possibly resulting in error in\n\
9012  the approximation.\n\
9013  GRID_NNI, only weights greater than data will be accepted. If\n\
9014  0, all weights will be accepted.\n\
9015 ";
9016 static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
9017 Clear current (sub)page\n\
9018 \n\
9019 DESCRIPTION:\n\
9020 \n\
9021  Clears the current page, effectively erasing everything that have been\n\
9022  drawn. This command only works with interactive drivers; if the\n\
9023  driver does not support this, the page is filled with the background\n\
9024  color in use. If the current page is divided into subpages, only the\n\
9025  current subpage is erased. The nth subpage can be selected with\n\
9026  pladv(n).\n\
9027 \n\
9028  Redacted form: General: plclear()\n\
9029 \n\
9030 \n\
9031  This function is not used in any examples.\n\
9032 \n\
9033 \n\
9034 \n\
9035 SYNOPSIS:\n\
9036 \n\
9037 plclear()\n\
9038 ";
9039 static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
9040 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
9041 \n\
9042 DESCRIPTION:\n\
9043 \n\
9044  Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
9045  and PLFLT alpha transparency value. This sets the entire color map --\n\
9046  only as many colors as specified will be allocated.\n\
9047 \n\
9048  Redacted form: plscmap0a(r, g, b, alpha)\n\
9049 \n\
9050  This function is used in examples 30.\n\
9051 \n\
9052 \n\
9053 \n\
9054 SYNOPSIS:\n\
9055 \n\
9056 plscmap0a(r, g, b, alpha, ncol0)\n\
9057 \n\
9058 ARGUMENTS:\n\
9059 \n\
9060  r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9061  integers (0-255) representing the degree of red in the color.\n\
9062 \n\
9063  g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9064  integers (0-255) representing the degree of green in the color.\n\
9065 \n\
9066  b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9067  integers (0-255) representing the degree of blue in the color.\n\
9068 \n\
9069  alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
9070  representing the alpha transparency of the color.\n\
9071 \n\
9072  ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9073  vectors.\n\
9074 ";
9075 static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
9076 Set 8-bit RGB values for given cmap0 color index\n\
9077 \n\
9078 DESCRIPTION:\n\
9079 \n\
9080  Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
9081  index. Overwrites the previous color value for the given index and,\n\
9082  thus, does not result in any additional allocation of space for\n\
9083  colors.\n\
9084 \n\
9085  Redacted form: plscol0(icol0, r, g, b)\n\
9086 \n\
9087  This function is used in any example 31.\n\
9088 \n\
9089 \n\
9090 \n\
9091 SYNOPSIS:\n\
9092 \n\
9093 plscol0(icol0, r, g, b)\n\
9094 \n\
9095 ARGUMENTS:\n\
9096 \n\
9097  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
9098  number of colors (which is set by default, by plscmap0n, or even\n\
9099  by plscmap0).\n\
9100 \n\
9101  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9102  degree of red in the color.\n\
9103 \n\
9104  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9105  degree of green in the color.\n\
9106 \n\
9107  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9108  degree of blue in the color.\n\
9109 ";
9110 static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
9111 Set up transformation from metafile coordinates\n\
9112 \n\
9113 DESCRIPTION:\n\
9114 \n\
9115  Set up transformation from metafile coordinates. The size of the plot\n\
9116  is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
9117  general-purpose facility just yet (not sure why the user would need\n\
9118  it, for one).\n\
9119 \n\
9120  Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
9121  dimypmm)\n\
9122 \n\
9123  This function is not used in any examples.\n\
9124 \n\
9125 \n\
9126 \n\
9127 SYNOPSIS:\n\
9128 \n\
9129 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
9130 \n\
9131 ARGUMENTS:\n\
9132 \n\
9133  dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
9134 \n\
9135  dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
9136 \n\
9137  dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
9138 \n\
9139  dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
9140 \n\
9141  dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9142 \n\
9143  dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9144 ";
9145 static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
9146 Creates a new stream and makes it the default\n\
9147 \n\
9148 DESCRIPTION:\n\
9149 \n\
9150  Creates a new stream and makes it the default. Differs from using\n\
9151  plsstrm, in that a free stream number is found, and returned.\n\
9152  Unfortunately, I have to start at stream 1 and work upward, since\n\
9153  stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
9154  that no initial, library-opening call is required. So stream 0 must\n\
9155  be preallocated, and there is no simple way of determining whether it\n\
9156  is already in use or not.\n\
9157 \n\
9158  Redacted form: plmkstrm(p_strm)\n\
9159 \n\
9160  This function is used in examples 1 and 20.\n\
9161 \n\
9162 \n\
9163 \n\
9164 SYNOPSIS:\n\
9165 \n\
9166 plmkstrm(p_strm)\n\
9167 \n\
9168 ARGUMENTS:\n\
9169 \n\
9170  p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
9171  number of the created stream.\n\
9172 ";
9173 static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
9174 Get page parameters\n\
9175 \n\
9176 DESCRIPTION:\n\
9177 \n\
9178  Gets the current page configuration. The length and offset values are\n\
9179  expressed in units that are specific to the current driver. For\n\
9180  instance: screen drivers will usually interpret them as number of\n\
9181  pixels, whereas printer drivers will usually use mm.\n\
9182 \n\
9183  Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9184 \n\
9185  This function is used in examples 14 and 31.\n\
9186 \n\
9187 \n\
9188 \n\
9189 SYNOPSIS:\n\
9190 \n\
9191 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9192 \n\
9193 ARGUMENTS:\n\
9194 \n\
9195  p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9196  pixels/inch (DPI) in x.\n\
9197 \n\
9198  p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9199  pixels/inch (DPI) in y.\n\
9200 \n\
9201  p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9202  length.\n\
9203 \n\
9204  p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9205  length.\n\
9206 \n\
9207  p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9208  offset.\n\
9209 \n\
9210  p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9211  offset.\n\
9212 ";
9213 static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
9214 Set format for date / time labels\n\
9215 \n\
9216 DESCRIPTION:\n\
9217 \n\
9218  Sets the format for date / time labels. To enable date / time format\n\
9219  labels see the options to plbox, plbox3, and plenv.\n\
9220 \n\
9221  Redacted form: pltimefmt(fmt)\n\
9222 \n\
9223  This function is used in example 29.\n\
9224 \n\
9225 \n\
9226 \n\
9227 SYNOPSIS:\n\
9228 \n\
9229 pltimefmt(fmt)\n\
9230 \n\
9231 ARGUMENTS:\n\
9232 \n\
9233  fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
9234  interpreted similarly to the format specifier of typical system\n\
9235  strftime routines except that PLplot ignores locale and also\n\
9236  supplies some useful extensions in the context of plotting. All\n\
9237  text in the string is printed as-is other than conversion\n\
9238  specifications which take the form of a \'%\' character followed by\n\
9239  further conversion specification character. The conversion\n\
9240  specifications which are similar to those provided by system\n\
9241  strftime routines are the following: %a: The abbreviated (English)\n\
9242  weekday name.\n\
9243  %A: The full (English) weekday name.\n\
9244  %b: The abbreviated (English) month name.\n\
9245  %B: The full (English) month name.\n\
9246  %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
9247  %C: The century number (year/100) as a 2-digit integer.\n\
9248  %d: The day of the month as a decimal number (range 01 to 31).\n\
9249  %D: Equivalent to %m/%d/%y (non-ISO).\n\
9250  %e: Like %d, but a leading zero is replaced by a space.\n\
9251  %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
9252  %h: Equivalent to %b.\n\
9253  %H: The hour as a decimal number using a 24-hour clock (range\n\
9254  00 to 23).\n\
9255  %I: The hour as a decimal number using a 12-hour clock (range\n\
9256  01 to 12).\n\
9257  %j: The day of the year as a decimal number (range 001 to\n\
9258  366).\n\
9259  %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
9260  23); single digits are preceded by a blank. (See also %H.)\n\
9261  %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
9262  12); single digits are preceded by a blank. (See also %I.)\n\
9263  %m: The month as a decimal number (range 01 to 12).\n\
9264  %M: The minute as a decimal number (range 00 to 59).\n\
9265  %n: A newline character.\n\
9266  %p: Either \"AM\" or \"PM\" according to the given time value.\n\
9267  Noon is treated as \"PM\" and midnight as \"AM\".\n\
9268  %r: Equivalent to %I:%M:%S %p.\n\
9269  %R: The time in 24-hour notation (%H:%M). For a version\n\
9270  including the seconds, see %T below.\n\
9271  %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
9272  +0000 (UTC).\n\
9273  %S: The second as a decimal number (range 00 to 60). (The\n\
9274  range is up to 60 to allow for occasional leap seconds.)\n\
9275  %t: A tab character.\n\
9276  %T: The time in 24-hour notation (%H:%M:%S).\n\
9277  %u: The day of the week as a decimal, range 1 to 7, Monday\n\
9278  being 1. See also %w.\n\
9279  %U: The week number of the current year as a decimal number,\n\
9280  range 00 to 53, starting with the first Sunday as the first\n\
9281  day of week 01. See also %V and %W.\n\
9282  %v: Equivalent to %e-%b-%Y.\n\
9283  %V: The ISO 8601 week number of the current year as a decimal\n\
9284  number, range 01 to 53, where week 1 is the first week that\n\
9285  has at least 4 days in the new year. See also %U and %W.\n\
9286  %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
9287  being 0. See also %u.\n\
9288  %W: The week number of the current year as a decimal number,\n\
9289  range 00 to 53, starting with the first Monday as the first\n\
9290  day of week 01.\n\
9291  %x: Equivalent to %a %b %d %Y.\n\
9292  %X: Equivalent to %T.\n\
9293  %y: The year as a decimal number without a century (range 00\n\
9294  to 99).\n\
9295  %Y: The year as a decimal number including a century.\n\
9296  %z: The UTC time-zone string = \"+0000\".\n\
9297  %Z: The UTC time-zone abbreviation = \"UTC\".\n\
9298  %+: The UTC date and time in default format of the Unix date\n\
9299  command which is equivalent to %a %b %d %T %Z %Y.\n\
9300  %%: A literal \"%\" character.\n\
9301  The conversion specifications which are extensions to those normally\n\
9302  provided by system strftime routines are the following: %(0-9):\n\
9303  The fractional part of the seconds field (including leading\n\
9304  decimal point) to the specified accuracy. Thus %S%3 would give\n\
9305  seconds to millisecond accuracy (00.000).\n\
9306  %.: The fractional part of the seconds field (including\n\
9307  leading decimal point) to the maximum available accuracy. Thus\n\
9308  %S%. would give seconds with fractional part up to 9 decimal\n\
9309  places if available.\n\
9310 ";
9311 static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
9312 Specify viewport using aspect ratio only\n\
9313 \n\
9314 DESCRIPTION:\n\
9315 \n\
9316  Selects the largest viewport with the given aspect ratio within the\n\
9317  subpage that leaves a standard margin (left-hand margin of eight\n\
9318  character heights, and a margin around the other three sides of five\n\
9319  character heights).\n\
9320 \n\
9321  Redacted form: plvasp(aspect)\n\
9322 \n\
9323  This function is used in example 13.\n\
9324 \n\
9325 \n\
9326 \n\
9327 SYNOPSIS:\n\
9328 \n\
9329 plvasp(aspect)\n\
9330 \n\
9331 ARGUMENTS:\n\
9332 \n\
9333  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9334  axis of resulting viewport.\n\
9335 ";
9336 static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
9337 Set output file name\n\
9338 \n\
9339 DESCRIPTION:\n\
9340 \n\
9341  Sets the current output file name, if applicable. If the file name\n\
9342  has not been specified and is required by the driver, the user will be\n\
9343  prompted for it. If using the X-windows output driver, this sets the\n\
9344  display name. This routine, if used, must be called before\n\
9345  initializing PLplot.\n\
9346 \n\
9347  Redacted form: plsfnam(fnam)\n\
9348 \n\
9349  This function is used in examples 1 and 20.\n\
9350 \n\
9351 \n\
9352 \n\
9353 SYNOPSIS:\n\
9354 \n\
9355 plsfnam(fnam)\n\
9356 \n\
9357 ARGUMENTS:\n\
9358 \n\
9359  fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9360  the file name.\n\
9361 ";
9362 static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
9363 Vector plot\n\
9364 \n\
9365 DESCRIPTION:\n\
9366 \n\
9367  Draws a plot of vector data contained in the matrices (\n\
9368  u[\n\
9369  nx][\n\
9370  ny],\n\
9371  v[\n\
9372  nx][\n\
9373  ny]) . The scaling factor for the vectors is given by scale. A\n\
9374  transformation routine pointed to by pltr with a pointer pltr_data for\n\
9375  additional data required by the transformation routine to map indices\n\
9376  within the matrices to the world coordinates. The style of the vector\n\
9377  arrow may be set using plsvect.\n\
9378 \n\
9379  Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9380  discussion) the pltr, pltr_data callback arguments are sometimes\n\
9381  replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9382  with either one or two dimensions.\n\
9383 \n\
9384  This function is used in example 22.\n\
9385 \n\
9386 \n\
9387 \n\
9388 SYNOPSIS:\n\
9389 \n\
9390 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9391 \n\
9392 ARGUMENTS:\n\
9393 \n\
9394  u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9395  and y components of the vector data to be plotted.\n\
9396 \n\
9397  nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9398 \n\
9399  scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9400  the vectors for plotting. If scale = 0 then the scaling factor is\n\
9401  automatically calculated for the data. If scale < 0 then the\n\
9402  scaling factor is automatically calculated for the data and then\n\
9403  multiplied by -\n\
9404  scale. If scale > 0 then the scaling factor is set to scale.\n\
9405 \n\
9406  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9407  defines the transformation between the zero-based indices of the\n\
9408  matrices u and v and world coordinates.For the C case,\n\
9409  transformation functions are provided in the PLplot library: pltr0\n\
9410  for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9411  mappings respectively defined by vectors and matrices. In\n\
9412  addition, C callback routines for the transformation can be\n\
9413  supplied by the user such as the mypltr function in\n\
9414  examples/c/x09c.c which provides a general linear transformation\n\
9415  between index coordinates and world coordinates.For languages\n\
9416  other than C you should consult the PLplot documentation for the\n\
9417  details concerning how PLTRANSFORM_callback arguments are\n\
9418  interfaced. However, in general, a particular pattern of\n\
9419  callback-associated arguments such as a tr vector with 6 elements;\n\
9420  xg and yg vectors; or xg and yg matrices are respectively\n\
9421  interfaced to a linear-transformation routine similar to the above\n\
9422  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9423  sophisticated bindings (see, e.g., the PLplot documentation)\n\
9424  support native language callbacks for handling index to\n\
9425  world-coordinate transformations. Examples of these various\n\
9426  approaches are given in examples/<language>x09*,\n\
9427  examples/<language>x16*, examples/<language>x20*,\n\
9428  examples/<language>x21*, and examples/<language>x22*, for all our\n\
9429  supported languages.\n\
9430 \n\
9431  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9432  information to pltr0, pltr1, pltr2, or whatever callback routine\n\
9433  that is externally supplied.\n\
9434 ";
9435 static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
9436 Set parameters that define current plot-space window\n\
9437 \n\
9438 DESCRIPTION:\n\
9439 \n\
9440  Set relative minima and maxima that define the current plot-space\n\
9441  window. If plsdiplt is not called the default values of xmin, ymin,\n\
9442  xmax, and ymax are 0., 0., 1., and 1.\n\
9443 \n\
9444  Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9445 \n\
9446  This function is used in example 31.\n\
9447 \n\
9448 \n\
9449 \n\
9450 SYNOPSIS:\n\
9451 \n\
9452 plsdiplt(xmin, ymin, xmax, ymax)\n\
9453 \n\
9454 ARGUMENTS:\n\
9455 \n\
9456  xmin (PLFLT, input) : Relative minimum in x.\n\
9457 \n\
9458  ymin (PLFLT, input) : Relative minimum in y.\n\
9459 \n\
9460  xmax (PLFLT, input) : Relative maximum in x.\n\
9461 \n\
9462  ymax (PLFLT, input) : Relative maximum in y.\n\
9463 ";
9464 static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
9465 Select line style\n\
9466 \n\
9467 DESCRIPTION:\n\
9468 \n\
9469  This sets the line style according to one of eight predefined patterns\n\
9470  (also see plstyl).\n\
9471 \n\
9472  Redacted form: pllsty(lin)\n\
9473 \n\
9474  This function is used in examples 9, 12, 22, and 25.\n\
9475 \n\
9476 \n\
9477 \n\
9478 SYNOPSIS:\n\
9479 \n\
9480 pllsty(lin)\n\
9481 \n\
9482 ARGUMENTS:\n\
9483 \n\
9484  lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9485  a continuous line, line style 2 is a line with short dashes and\n\
9486  gaps, line style 3 is a line with long dashes and gaps, line style\n\
9487  4 has long dashes and short gaps and so on.\n\
9488 ";
9489 static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
9490 Plot a glyph at the specified points\n\
9491 \n\
9492 DESCRIPTION:\n\
9493 \n\
9494  Plot a glyph at the specified points. (This function is largely\n\
9495  superseded by plstring which gives access to many[!] more glyphs.)\n\
9496 \n\
9497  Redacted form: plsym(x, y, code)\n\
9498 \n\
9499  This function is used in example 7.\n\
9500 \n\
9501 \n\
9502 \n\
9503 SYNOPSIS:\n\
9504 \n\
9505 plsym(n, x, y, code)\n\
9506 \n\
9507 ARGUMENTS:\n\
9508 \n\
9509  n (PLINT, input) : Number of points in the x and y vectors.\n\
9510 \n\
9511  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9512  the points.\n\
9513 \n\
9514  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9515  the points.\n\
9516 \n\
9517  code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9518  to be plotted at each of the n points.\n\
9519 ";
9520 static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
9521 Set the device (keyword) name\n\
9522 \n\
9523 DESCRIPTION:\n\
9524 \n\
9525  Set the device (keyword) name.\n\
9526 \n\
9527  Redacted form: plsdev(devname)\n\
9528 \n\
9529  This function is used in examples 1, 14, and 20.\n\
9530 \n\
9531 \n\
9532 \n\
9533 SYNOPSIS:\n\
9534 \n\
9535 plsdev(devname)\n\
9536 \n\
9537 ARGUMENTS:\n\
9538 \n\
9539  devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9540  containing the device name keyword of the required output device.\n\
9541  If\n\
9542  devname is NULL or if the first character of the string is a ``?\'\',\n\
9543  the normal (prompted) start up is used.\n\
9544 ";
9545 static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
9546 Set the background color by 8-bit RGB value\n\
9547 \n\
9548 DESCRIPTION:\n\
9549 \n\
9550  Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9551  the PLplot documentation).\n\
9552 \n\
9553  Redacted form: plscolbg(r, g, b)\n\
9554 \n\
9555  This function is used in examples 15 and 31.\n\
9556 \n\
9557 \n\
9558 \n\
9559 SYNOPSIS:\n\
9560 \n\
9561 plscolbg(r, g, b)\n\
9562 \n\
9563 ARGUMENTS:\n\
9564 \n\
9565  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9566  degree of red in the color.\n\
9567 \n\
9568  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9569  degree of green in the color.\n\
9570 \n\
9571  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9572  degree of blue in the color.\n\
9573 ";
9574 static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
9575 Set parameters incrementally (zoom mode) that define current plot-space window\n\
9576 \n\
9577 DESCRIPTION:\n\
9578 \n\
9579  Set relative minima and maxima incrementally (zoom mode) that define\n\
9580  the current plot-space window. This function has the same effect as\n\
9581  plsdiplt if that function has not been previously called. Otherwise,\n\
9582  this function implements zoom mode using the transformation min_used =\n\
9583  old_min + old_length*min and max_used = old_min + old_length*max for\n\
9584  each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
9585  repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9586 \n\
9587  Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9588 \n\
9589  This function is used in example 31.\n\
9590 \n\
9591 \n\
9592 \n\
9593 SYNOPSIS:\n\
9594 \n\
9595 plsdiplz(xmin, ymin, xmax, ymax)\n\
9596 \n\
9597 ARGUMENTS:\n\
9598 \n\
9599  xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9600 \n\
9601  ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9602 \n\
9603  xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9604 \n\
9605  ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9606 ";
9607 static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
9608 Advance to the next family file on the next new page\n\
9609 \n\
9610 DESCRIPTION:\n\
9611 \n\
9612  Advance to the next family file on the next new page.\n\
9613 \n\
9614  Redacted form: plfamadv()\n\
9615 \n\
9616  This function is not used in any examples.\n\
9617 \n\
9618 \n\
9619 \n\
9620 SYNOPSIS:\n\
9621 \n\
9622 plfamadv()\n\
9623 ";
9624 static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9625 Set number of colors in cmap0\n\
9626 \n\
9627 DESCRIPTION:\n\
9628 \n\
9629  Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9630  (or reallocate) cmap0, and fill with default values for those colors\n\
9631  not previously allocated. The first 16 default colors are given in\n\
9632  the plcol0 documentation. For larger indices the default color is\n\
9633  red.\n\
9634 \n\
9635  The drivers are not guaranteed to support more than 16 colors.\n\
9636 \n\
9637  Redacted form: plscmap0n(ncol0)\n\
9638 \n\
9639  This function is used in examples 15, 16, and 24.\n\
9640 \n\
9641 \n\
9642 \n\
9643 SYNOPSIS:\n\
9644 \n\
9645 plscmap0n(ncol0)\n\
9646 \n\
9647 ARGUMENTS:\n\
9648 \n\
9649  ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9650  the cmap0 palette. If this number is zero or less, then the value\n\
9651  from the previous call to plscmap0n is used and if there is no\n\
9652  previous call, then a default value is used.\n\
9653 ";
9654 static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
9655 Plot latitude and longitude lines\n\
9656 \n\
9657 DESCRIPTION:\n\
9658 \n\
9659  Displays latitude and longitude on the current plot. The lines are\n\
9660  plotted in the current color and line style.\n\
9661 \n\
9662  Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9663  minlat, maxlat)\n\
9664 \n\
9665  This function is used in example 19.\n\
9666 \n\
9667 \n\
9668 \n\
9669 SYNOPSIS:\n\
9670 \n\
9671 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9672 \n\
9673 ARGUMENTS:\n\
9674 \n\
9675  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9676  transform the coordinate longitudes and latitudes to a plot\n\
9677  coordinate system. By using this transform, we can change from a\n\
9678  longitude, latitude coordinate to a polar stereographic project,\n\
9679  for example. Initially, x[0]..[n-1] are the longitudes and\n\
9680  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9681  mapform(), x[] and y[] should be replaced by the corresponding\n\
9682  plot coordinates. If no transform is desired, mapform can be\n\
9683  replaced by NULL.\n\
9684 \n\
9685  dlong (PLFLT, input) : The interval in degrees at which the\n\
9686  longitude lines are to be plotted.\n\
9687 \n\
9688  dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9689  lines are to be plotted.\n\
9690 \n\
9691  minlong (PLFLT, input) : The value of the longitude on the left\n\
9692  side of the plot. The value of minlong must be less than the value\n\
9693  of maxlong, and the quantity maxlong-minlong must be less than or\n\
9694  equal to 360.\n\
9695 \n\
9696  maxlong (PLFLT, input) : The value of the longitude on the right\n\
9697  side of the plot.\n\
9698 \n\
9699  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9700  background. One can always use -90.0 as the boundary outside the\n\
9701  plot window will be automatically eliminated. However, the\n\
9702  program will be faster if one can reduce the size of the\n\
9703  background plotted.\n\
9704 \n\
9705  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9706  background. One can always use 90.0 as the boundary outside the\n\
9707  plot window will be automatically eliminated.\n\
9708 ";
9709 static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9710 Convert RGB color to HLS\n\
9711 \n\
9712 DESCRIPTION:\n\
9713 \n\
9714  Convert RGB color coordinates to HLS\n\
9715 \n\
9716  Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9717 \n\
9718 \n\
9719  This function is used in example 2.\n\
9720 \n\
9721 \n\
9722 \n\
9723 SYNOPSIS:\n\
9724 \n\
9725 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9726 \n\
9727 ARGUMENTS:\n\
9728 \n\
9729  r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9730 \n\
9731  g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9732 \n\
9733  b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9734 \n\
9735  p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9736  degrees (0.0-360.0) on the color cylinder.\n\
9737 \n\
9738  p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9739  expressed as a fraction (0.0-1.0) of the axis of the color\n\
9740  cylinder.\n\
9741 \n\
9742  p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9743  expressed as a fraction (0.0-1.0) of the radius of the color\n\
9744  cylinder.\n\
9745 ";
9746 static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
9747 Plot a glyph at the specified 3D points\n\
9748 \n\
9749 DESCRIPTION:\n\
9750 \n\
9751  Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9752  many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9753  this function similar to what is done for plline3. The glyph is\n\
9754  specified with a PLplot user string. Note that the user string is not\n\
9755  actually limited to one glyph so it is possible (but not normally\n\
9756  useful) to plot more than one glyph at the specified points with this\n\
9757  function. As with plmtex and plptex, the user string can contain FCI\n\
9758  escapes to determine the font, UTF-8 code to determine the glyph or\n\
9759  else PLplot escapes for Hershey or unicode text to determine the\n\
9760  glyph.\n\
9761 \n\
9762  Redacted form: plstring3(x, y, z, string)\n\
9763 \n\
9764  This function is used in example 18.\n\
9765 \n\
9766 \n\
9767 \n\
9768 SYNOPSIS:\n\
9769 \n\
9770 plstring3(n, x, y, z, string)\n\
9771 \n\
9772 ARGUMENTS:\n\
9773 \n\
9774  n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9775 \n\
9776  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9777  the points.\n\
9778 \n\
9779  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9780  the points.\n\
9781 \n\
9782  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9783  the points.\n\
9784 \n\
9785  string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9786  the glyph(s) to be plotted at each of the n points. points.\n\
9787 ";
9788 static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
9789 Switch to text screen\n\
9790 \n\
9791 DESCRIPTION:\n\
9792 \n\
9793  Sets an interactive device to text mode, used in conjunction with\n\
9794  plgra to allow graphics and text to be interspersed. On a device\n\
9795  which supports separate text and graphics windows, this command causes\n\
9796  control to be switched to the text window. This can be useful for\n\
9797  printing diagnostic messages or getting user input, which would\n\
9798  otherwise interfere with the plots. The program must switch back to\n\
9799  the graphics window before issuing plot commands, as the text (or\n\
9800  console) device will probably become quite confused otherwise. If\n\
9801  already in text mode, this command is ignored. It is also ignored on\n\
9802  devices which only support a single window or use a different method\n\
9803  for shifting focus (see also plgra).\n\
9804 \n\
9805  Redacted form: pltext()\n\
9806 \n\
9807  This function is used in example 1.\n\
9808 \n\
9809 \n\
9810 \n\
9811 SYNOPSIS:\n\
9812 \n\
9813 pltext()\n\
9814 ";
9815 static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
9816 Get parameters that define current plot-space window\n\
9817 \n\
9818 DESCRIPTION:\n\
9819 \n\
9820  Get relative minima and maxima that define current plot-space window.\n\
9821  If plsdiplt has not been called the default values pointed to by\n\
9822  p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9823 \n\
9824  Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9825 \n\
9826  This function is used in example 31.\n\
9827 \n\
9828 \n\
9829 \n\
9830 SYNOPSIS:\n\
9831 \n\
9832 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9833 \n\
9834 ARGUMENTS:\n\
9835 \n\
9836  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9837  minimum in x.\n\
9838 \n\
9839  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9840  minimum in y.\n\
9841 \n\
9842  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9843  maximum in x.\n\
9844 \n\
9845  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9846  maximum in y.\n\
9847 ";
9848 static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
9849 Get the (current) run level\n\
9850 \n\
9851 DESCRIPTION:\n\
9852 \n\
9853  Get the (current) run level. Valid settings are: 0, uninitialized\n\
9854  1, initialized\n\
9855  2, viewport defined\n\
9856  3, world coordinates defined\n\
9857 \n\
9858 \n\
9859  Redacted form: plglevel(p_level)\n\
9860 \n\
9861  This function is used in example 31.\n\
9862 \n\
9863 \n\
9864 \n\
9865 SYNOPSIS:\n\
9866 \n\
9867 plglevel(p_level)\n\
9868 \n\
9869 ARGUMENTS:\n\
9870 \n\
9871  p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9872  level.\n\
9873 ";
9874 static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
9875 Plot a histogram from binned data\n\
9876 \n\
9877 DESCRIPTION:\n\
9878 \n\
9879  Plots a histogram consisting of nbin bins. The value associated with\n\
9880  the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9881  placed in y[i]. For proper operation, the values in x[i] must form a\n\
9882  strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9883  of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9884  placed midway between the values in the x vector. Also see plhist for\n\
9885  drawing histograms from unbinned data.\n\
9886 \n\
9887  Redacted form: General: plbin(x, y, opt)\n\
9888  Python: plbin(nbin, x, y, opt)\n\
9889 \n\
9890 \n\
9891  This function is not used in any examples.\n\
9892 \n\
9893 \n\
9894 \n\
9895 SYNOPSIS:\n\
9896 \n\
9897 plbin(nbin, x, y, opt)\n\
9898 \n\
9899 ARGUMENTS:\n\
9900 \n\
9901  nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9902  and y vectors.)\n\
9903 \n\
9904  x (PLFLT_VECTOR, input) : A vector containing values associated\n\
9905  with bins. These must form a strictly increasing sequence.\n\
9906 \n\
9907  y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
9908  proportional to the number of points in each bin. This is a PLFLT\n\
9909  (instead of PLINT) vector so as to allow histograms of\n\
9910  probabilities, etc.\n\
9911 \n\
9912  opt (PLINT, input) : Is a combination of several flags:\n\
9913  opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9914  outer bins are expanded to fill up the entire x-axis and bins of\n\
9915  zero height are simply drawn.\n\
9916  opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9917  between the x values. If the values in x are equally spaced,\n\
9918  the values are the center values of the bins.\n\
9919  opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9920  size as the ones inside.\n\
9921  opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9922  (there is a gap for such bins).\n\
9923 ";
9924 static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
9925 Plot a 2D matrix using cmap1\n\
9926 \n\
9927 DESCRIPTION:\n\
9928 \n\
9929  Plot a 2D matrix using cmap1.\n\
9930 \n\
9931  Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
9932  zmax, valuemin, valuemax, pltr, pltr_data)\n\
9933 \n\
9934 \n\
9935  This function is used in example 20.\n\
9936 \n\
9937 \n\
9938 \n\
9939 SYNOPSIS:\n\
9940 \n\
9941 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9942 \n\
9943 ARGUMENTS:\n\
9944 \n\
9945  idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
9946  plot. Should have dimensions of\n\
9947  nx by\n\
9948  ny.\n\
9949 \n\
9950  nx, ny (PLINT, input) : Dimensions of idata\n\
9951 \n\
9952  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
9953  pltr below for how these arguments are used (only for the special case\n\
9954  when the callback function\n\
9955  pltr is not supplied).\n\
9956 \n\
9957  zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9958  (inclusive) will be plotted.\n\
9959 \n\
9960  valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9961  values to use for value to color mappings. A datum equal to or\n\
9962  less than valuemin will be plotted with color 0.0, while a datum\n\
9963  equal to or greater than valuemax will be plotted with color 1.0.\n\
9964  Data between valuemin and valuemax map linearly to colors in the\n\
9965  range (0.0-1.0).\n\
9966 \n\
9967  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9968  defines the transformation between the zero-based indices of the\n\
9969  matrix idata and world coordinates. If\n\
9970  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
9971  indices of idata are mapped to the range\n\
9972  xmin through\n\
9973  xmax and the y indices of idata are mapped to the range\n\
9974  ymin through\n\
9975  ymax.For the C case, transformation functions are provided in the\n\
9976  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
9977  pltr2 for arbitrary mappings respectively defined by vectors and\n\
9978  matrices. In addition, C callback routines for the transformation\n\
9979  can be supplied by the user such as the mypltr function in\n\
9980  examples/c/x09c.c which provides a general linear transformation\n\
9981  between index coordinates and world coordinates.For languages\n\
9982  other than C you should consult the PLplot documentation for the\n\
9983  details concerning how PLTRANSFORM_callback arguments are\n\
9984  interfaced. However, in general, a particular pattern of\n\
9985  callback-associated arguments such as a tr vector with 6 elements;\n\
9986  xg and yg vectors; or xg and yg matrices are respectively\n\
9987  interfaced to a linear-transformation routine similar to the above\n\
9988  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9989  sophisticated bindings (see, e.g., the PLplot documentation)\n\
9990  support native language callbacks for handling index to\n\
9991  world-coordinate transformations. Examples of these various\n\
9992  approaches are given in examples/<language>x09*,\n\
9993  examples/<language>x16*, examples/<language>x20*,\n\
9994  examples/<language>x21*, and examples/<language>x22*, for all our\n\
9995  supported languages.\n\
9996 \n\
9997  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9998  information to pltr0, pltr1, pltr2, or whatever routine is\n\
9999  externally supplied.\n\
10000 ";
10001 static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
10002 Get family, style and weight of the current font\n\
10003 \n\
10004 DESCRIPTION:\n\
10005 \n\
10006  Gets information about current font. See the PLplot documentation for\n\
10007  more information on font selection.\n\
10008 \n\
10009  Redacted form: plgfont(p_family, p_style, p_weight)\n\
10010 \n\
10011  This function is used in example 23.\n\
10012 \n\
10013 \n\
10014 \n\
10015 SYNOPSIS:\n\
10016 \n\
10017 plgfont(p_family, p_style, p_weight)\n\
10018 \n\
10019 ARGUMENTS:\n\
10020 \n\
10021  p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10022  font family. The available values are given by the PL_FCI_*\n\
10023  constants in plplot.h. Current options are PL_FCI_SANS,\n\
10024  PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
10025  p_family is NULL then the font family is not returned.\n\
10026 \n\
10027  p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10028  font style. The available values are given by the PL_FCI_*\n\
10029  constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
10030  PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
10031  style is not returned.\n\
10032 \n\
10033  p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10034  font weight. The available values are given by the PL_FCI_*\n\
10035  constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
10036  PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
10037  returned.\n\
10038 ";
10039 static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
10040 Get z axis parameters\n\
10041 \n\
10042 DESCRIPTION:\n\
10043 \n\
10044  Identical to plgxax, except that arguments are flags for z axis. See\n\
10045  the description of plgxax for more detail.\n\
10046 \n\
10047  Redacted form: plgzax(p_digmax, p_digits)\n\
10048 \n\
10049  This function is used in example 31.\n\
10050 \n\
10051 \n\
10052 \n\
10053 SYNOPSIS:\n\
10054 \n\
10055 plgzax(p_digmax, p_digits)\n\
10056 \n\
10057 ARGUMENTS:\n\
10058 \n\
10059  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
10060  number of digits for the z axis. If nonzero, the printed label\n\
10061  has been switched to a floating-point representation when the\n\
10062  number of digits exceeds this value.\n\
10063 \n\
10064  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
10065  number of digits for the numeric labels (z axis) from the last\n\
10066  plot.\n\
10067 ";
10068 static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
10069 Write text inside the viewport of a 3D plot\n\
10070 \n\
10071 DESCRIPTION:\n\
10072 \n\
10073  Writes text at a specified position and inclination and with a\n\
10074  specified shear within the viewport. Text is clipped at the viewport\n\
10075  boundaries. The reference point of a string lies along a line passing\n\
10076  through the string at half the height of a capital letter. The\n\
10077  position of the reference point along this line is determined by just,\n\
10078  and the reference point is placed at world coordinates (\n\
10079  wx,\n\
10080  wy,\n\
10081  wz) within the viewport. The inclination and shear of the string is\n\
10082  specified in terms of differences of world coordinates making it easy\n\
10083  to write text parallel to a line in a graph.\n\
10084 \n\
10085  Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
10086 \n\
10087  This function is used in example 28.\n\
10088 \n\
10089 \n\
10090 \n\
10091 SYNOPSIS:\n\
10092 \n\
10093 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
10094 \n\
10095 ARGUMENTS:\n\
10096 \n\
10097  wx (PLFLT, input) : x world coordinate of reference point of\n\
10098  string.\n\
10099 \n\
10100  wy (PLFLT, input) : y world coordinate of reference point of\n\
10101  string.\n\
10102 \n\
10103  wz (PLFLT, input) : z world coordinate of reference point of\n\
10104  string.\n\
10105 \n\
10106  dx (PLFLT, input) : Together with dy and\n\
10107  dz , this specifies the inclination of the string. The baseline of\n\
10108  the string is parallel to a line joining (\n\
10109  x,\n\
10110  y,\n\
10111  z) to (\n\
10112  x+\n\
10113  dx,\n\
10114  y+\n\
10115  dy,\n\
10116  z+\n\
10117  dz) .\n\
10118 \n\
10119  dy (PLFLT, input) : Together with dx and\n\
10120  dz, this specifies the inclination of the string.\n\
10121 \n\
10122  dz (PLFLT, input) : Together with dx and\n\
10123  dy, this specifies the inclination of the string.\n\
10124 \n\
10125  sx (PLFLT, input) : Together with sy and\n\
10126  sz , this specifies the shear of the string. The string is sheared so\n\
10127  that the characters are vertically parallel to a line joining (\n\
10128  x,\n\
10129  y,\n\
10130  z) to (\n\
10131  x+\n\
10132  sx,\n\
10133  y+\n\
10134  sy,\n\
10135  z+\n\
10136  sz) . If sx =\n\
10137  sy =\n\
10138  sz = 0.) then the text is not sheared.\n\
10139 \n\
10140  sy (PLFLT, input) : Together with sx and\n\
10141  sz, this specifies shear of the string.\n\
10142 \n\
10143  sz (PLFLT, input) : Together with sx and\n\
10144  sy, this specifies shear of the string.\n\
10145 \n\
10146  just (PLFLT, input) : Specifies the position of the string relative\n\
10147  to its reference point. If just=0. , the reference point is at\n\
10148  the left and if just=1. , it is at the right of the string. Other\n\
10149  values of just give intermediate justifications.\n\
10150 \n\
10151  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
10152  written out.\n\
10153 ";
10154 static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
10155 Draw a box with axes, etc. with arbitrary origin\n\
10156 \n\
10157 DESCRIPTION:\n\
10158 \n\
10159  Draws a box around the currently defined viewport with arbitrary\n\
10160  world-coordinate origin specified by x0 and y0 and labels it with\n\
10161  world coordinate values appropriate to the window. Thus plaxes should\n\
10162  only be called after defining both viewport and window. The ascii\n\
10163  character strings xopt and yopt specify how the box should be drawn as\n\
10164  described below. If ticks and/or subticks are to be drawn for a\n\
10165  particular axis, the tick intervals and number of subintervals may be\n\
10166  specified explicitly, or they may be defaulted by setting the\n\
10167  appropriate arguments to zero.\n\
10168 \n\
10169  Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
10170  ytick, nysub)\n\
10171 \n\
10172 \n\
10173  This function is not used in any examples.\n\
10174 \n\
10175 \n\
10176 \n\
10177 SYNOPSIS:\n\
10178 \n\
10179 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
10180 \n\
10181 ARGUMENTS:\n\
10182 \n\
10183  x0 (PLFLT, input) : World X coordinate of origin.\n\
10184 \n\
10185  y0 (PLFLT, input) : World Y coordinate of origin.\n\
10186 \n\
10187  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10188  options for the x axis. The string can include any combination of\n\
10189  the following letters (upper or lower case) in any order: a: Draws\n\
10190  axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
10191  (x=0).\n\
10192  b: Draws bottom (X) or left (Y) edge of frame.\n\
10193  c: Draws top (X) or right (Y) edge of frame.\n\
10194  d: Plot labels as date / time. Values are assumed to be\n\
10195  seconds since the epoch (as used by gmtime).\n\
10196  f: Always use fixed point numeric labels.\n\
10197  g: Draws a grid at the major tick interval.\n\
10198  h: Draws a grid at the minor tick interval.\n\
10199  i: Inverts tick marks, so they are drawn outwards, rather than\n\
10200  inwards.\n\
10201  l: Labels axis logarithmically. This only affects the labels,\n\
10202  not the data, and so it is necessary to compute the logarithms\n\
10203  of data points before passing them to any of the drawing\n\
10204  routines.\n\
10205  m: Writes numeric labels at major tick intervals in the\n\
10206  unconventional location (above box for X, right of box for Y).\n\
10207  n: Writes numeric labels at major tick intervals in the\n\
10208  conventional location (below box for X, left of box for Y).\n\
10209  o: Use custom labelling function to generate axis label text.\n\
10210  The custom labelling function can be defined with the\n\
10211  plslabelfunc command.\n\
10212  s: Enables subticks between major ticks, only valid if t is\n\
10213  also specified.\n\
10214  t: Draws major ticks.\n\
10215  u: Exactly like \"b\" except don\'t draw edge line.\n\
10216  w: Exactly like \"c\" except don\'t draw edge line.\n\
10217  x: Exactly like \"t\" (including the side effect of the\n\
10218  numerical labels for the major ticks) except exclude drawing\n\
10219  the major and minor tick marks.\n\
10220 \n\
10221 \n\
10222  xtick (PLFLT, input) : World coordinate interval between major\n\
10223  ticks on the x axis. If it is set to zero, PLplot automatically\n\
10224  generates a suitable tick interval.\n\
10225 \n\
10226  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
10227  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10228  generates a suitable minor tick interval.\n\
10229 \n\
10230  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10231  options for the y axis. The string can include any combination of\n\
10232  the letters defined above for xopt, and in addition may contain:\n\
10233  v: Write numeric labels for the y axis parallel to the base of the\n\
10234  graph, rather than parallel to the axis.\n\
10235 \n\
10236 \n\
10237  ytick (PLFLT, input) : World coordinate interval between major\n\
10238  ticks on the y axis. If it is set to zero, PLplot automatically\n\
10239  generates a suitable tick interval.\n\
10240 \n\
10241  nysub (PLINT, input) : Number of subintervals between major y axis\n\
10242  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10243  generates a suitable minor tick interval.\n\
10244 ";
10245 static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
10246 Returns the background color (cmap0[0]) by 8-bit RGB value\n\
10247 \n\
10248 DESCRIPTION:\n\
10249 \n\
10250  Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
10251 \n\
10252  Redacted form: plgcolbg(r, g, b)\n\
10253 \n\
10254  This function is used in example 31.\n\
10255 \n\
10256 \n\
10257 \n\
10258 SYNOPSIS:\n\
10259 \n\
10260 plgcolbg(r, g, b)\n\
10261 \n\
10262 ARGUMENTS:\n\
10263 \n\
10264  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10265  in the range from 0 to 255.\n\
10266 \n\
10267  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10268  in the range from 0 to 255.\n\
10269 \n\
10270  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10271  in the range from 0 to 255.\n\
10272 ";
10273 static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
10274 Plot a glyph at the specified 3D points\n\
10275 \n\
10276 DESCRIPTION:\n\
10277 \n\
10278  Plot a glyph at the specified 3D points. (This function is largely\n\
10279  superseded by plstring3 which gives access to many[!] more glyphs.)\n\
10280  Set up the call to this function similar to what is done for plline3.\n\
10281  code=-1 means try to just draw a point. Right now it\'s just a move\n\
10282  and a draw at the same place. Not ideal, since a sufficiently\n\
10283  intelligent output device may optimize it away, or there may be faster\n\
10284  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
10285  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
10286  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
10287  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
10288  code <= 127 the corresponding printable ASCII character is plotted.\n\
10289 \n\
10290  Redacted form: plpoin3(x, y, z, code)\n\
10291 \n\
10292  This function is not used in any example.\n\
10293 \n\
10294 \n\
10295 \n\
10296 SYNOPSIS:\n\
10297 \n\
10298 plpoin3(n, x, y, z, code)\n\
10299 \n\
10300 ARGUMENTS:\n\
10301 \n\
10302  n (PLINT, input) : Number of points in the x and y vectors.\n\
10303 \n\
10304  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10305  points.\n\
10306 \n\
10307  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10308  points.\n\
10309 \n\
10310  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10311  points.\n\
10312 \n\
10313  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10314  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10315  each of the n points.\n\
10316 ";
10317 static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10318 Draw a polygon in 3 space\n\
10319 \n\
10320 DESCRIPTION:\n\
10321 \n\
10322  Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10323  like plline3, but differs from that function in that plpoly3 attempts\n\
10324  to determine if the polygon is viewable depending on the order of the\n\
10325  points within the vector and the value of ifcc. If the back of\n\
10326  polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10327  you want, then use plline3 instead.\n\
10328 \n\
10329  The points are assumed to be in a plane, and the directionality of the\n\
10330  plane is determined from the first three points. Additional points do\n\
10331  not have to lie on the plane defined by the first three, but if they\n\
10332  do not, then the determination of visibility obviously can\'t be 100%\n\
10333  accurate... So if you\'re 3 space polygons are too far from planar,\n\
10334  consider breaking them into smaller polygons. 3 points define a plane\n\
10335  :-).\n\
10336 \n\
10337  Bugs: If one of the first two segments is of zero length, or if they\n\
10338  are co-linear, the calculation of visibility has a 50/50 chance of\n\
10339  being correct. Avoid such situations :-). See x18c.c for an example\n\
10340  of this problem. (Search for 20.1).\n\
10341 \n\
10342  Redacted form: plpoly3(x, y, z, code)\n\
10343 \n\
10344  This function is used in example 18.\n\
10345 \n\
10346 \n\
10347 \n\
10348 SYNOPSIS:\n\
10349 \n\
10350 plpoly3(n, x, y, z, draw, ifcc)\n\
10351 \n\
10352 ARGUMENTS:\n\
10353 \n\
10354  n (PLINT, input) : Number of points defining line.\n\
10355 \n\
10356  x (PLFLT_VECTOR, input) : A vector containing\n\
10357  n x coordinates of points.\n\
10358 \n\
10359  y (PLFLT_VECTOR, input) : A vector containing\n\
10360  n y coordinates of points.\n\
10361 \n\
10362  z (PLFLT_VECTOR, input) : A vector containing\n\
10363  n z coordinates of points.\n\
10364 \n\
10365  draw (PLBOOL_VECTOR, input) : A vector containing\n\
10366  n-1 Boolean values which control drawing the segments of the polygon.\n\
10367  If draw[i] is true, then the polygon segment from index [i] to\n\
10368  [i+1] is drawn, otherwise, not.\n\
10369 \n\
10370  ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10371  polygon is determined by assuming the points are laid out in a\n\
10372  counter-clockwise order. Otherwise, the directionality of the\n\
10373  polygon is determined by assuming the points are laid out in a\n\
10374  clockwise order.\n\
10375 ";
10376 static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
10377 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10378 \n\
10379 DESCRIPTION:\n\
10380 \n\
10381  Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10382  PLFLT alpha transparency value (see the PLplot documentation).\n\
10383 \n\
10384  This function is used in example 31.\n\
10385 \n\
10386 \n\
10387 \n\
10388 SYNOPSIS:\n\
10389 \n\
10390 plscolbga(r, g, b, alpha)\n\
10391 \n\
10392 ARGUMENTS:\n\
10393 \n\
10394  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10395  degree of red in the color.\n\
10396 \n\
10397  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10398  degree of green in the color.\n\
10399 \n\
10400  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10401  degree of blue in the color.\n\
10402 \n\
10403  alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10404  (0.0-1.0).\n\
10405 ";
10406 static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
10407 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10408 \n\
10409 DESCRIPTION:\n\
10410 \n\
10411  Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10412  alpha transparency value.\n\
10413 \n\
10414  This function is used in example 31.\n\
10415 \n\
10416 \n\
10417 \n\
10418 SYNOPSIS:\n\
10419 \n\
10420 plgcolbga(r, g, b, alpha)\n\
10421 \n\
10422 ARGUMENTS:\n\
10423 \n\
10424  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10425  in the range from 0 to 255.\n\
10426 \n\
10427  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10428  in the range from 0 to 255.\n\
10429 \n\
10430  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10431  in the range from 0 to 255.\n\
10432 \n\
10433  alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10434  transparency in the range (0.0-1.0).\n\
10435 ";
10436 static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
10437 Draw error bars in x direction\n\
10438 \n\
10439 DESCRIPTION:\n\
10440 \n\
10441  Draws a set of n error bars in x direction, the i\'th error bar\n\
10442  extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10443  of the error bars are of length equal to the minor tick length\n\
10444  (settable using plsmin).\n\
10445 \n\
10446  Redacted form: General: plerrx(xmin, ymax, y)\n\
10447 \n\
10448 \n\
10449  This function is used in example 29.\n\
10450 \n\
10451 \n\
10452 \n\
10453 SYNOPSIS:\n\
10454 \n\
10455 plerrx(n, xmin, xmax, y)\n\
10456 \n\
10457 ARGUMENTS:\n\
10458 \n\
10459  n (PLINT, input) : Number of error bars to draw.\n\
10460 \n\
10461  xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10462  of the left-hand endpoints of the error bars.\n\
10463 \n\
10464  xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10465  of the right-hand endpoints of the error bars.\n\
10466 \n\
10467  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10468  the error bars.\n\
10469 ";
10470 static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
10471 Eject current page\n\
10472 \n\
10473 DESCRIPTION:\n\
10474 \n\
10475  Clears the graphics screen of an interactive device, or ejects a page\n\
10476  on a plotter. See plbop for more information.\n\
10477 \n\
10478  Redacted form: pleop()\n\
10479 \n\
10480  This function is used in example 2,14.\n\
10481 \n\
10482 \n\
10483 \n\
10484 SYNOPSIS:\n\
10485 \n\
10486 pleop()\n\
10487 ";
10488 static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
10489 Convert HLS color to RGB\n\
10490 \n\
10491 DESCRIPTION:\n\
10492 \n\
10493  Convert HLS color coordinates to RGB.\n\
10494 \n\
10495  Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10496 \n\
10497 \n\
10498  This function is used in example 2.\n\
10499 \n\
10500 \n\
10501 \n\
10502 SYNOPSIS:\n\
10503 \n\
10504 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10505 \n\
10506 ARGUMENTS:\n\
10507 \n\
10508  h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10509  cylinder.\n\
10510 \n\
10511  l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10512  the axis of the color cylinder.\n\
10513 \n\
10514  s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10515  the radius of the color cylinder.\n\
10516 \n\
10517  p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10518  (0.0-1.0) of the color.\n\
10519 \n\
10520  p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10521  intensity (0.0-1.0) of the color.\n\
10522 \n\
10523  p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10524  intensity (0.0-1.0) of the color.\n\
10525 ";
10526 static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
10527 Plot all or a subset of Shapefile data, filling the polygons\n\
10528 \n\
10529 DESCRIPTION:\n\
10530 \n\
10531  As per plmapline, however the items are filled in the same way as\n\
10532  plfill.\n\
10533 \n\
10534  Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10535  plotentries)\n\
10536 \n\
10537  This function is used in example 19.\n\
10538 \n\
10539 \n\
10540 \n\
10541 SYNOPSIS:\n\
10542 \n\
10543 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10544 \n\
10545 ARGUMENTS:\n\
10546 \n\
10547  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10548  transform the coordinates given in the shapefile into a plot\n\
10549  coordinate system. By using this transform, we can change from a\n\
10550  longitude, latitude coordinate to a polar stereographic project,\n\
10551  for example. Initially, x[0]..[n-1] are the longitudes and\n\
10552  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10553  mapform(), x[] and y[] should be replaced by the corresponding\n\
10554  plot coordinates. If no transform is desired, mapform can be\n\
10555  replaced by NULL.\n\
10556 \n\
10557  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10558  the file name of a set of Shapefile files without the file\n\
10559  extension.\n\
10560 \n\
10561  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10562  be in the same units as used by the Shapefile. You could use a\n\
10563  very large negative number to plot everything, but you can improve\n\
10564  performance by limiting the area drawn. The units must match those\n\
10565  of the Shapefile projection, which may be for example longitude or\n\
10566  distance. The value of minx must be less than the value of maxx.\n\
10567 \n\
10568  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10569  use a very large number to plot everything, but you can improve\n\
10570  performance by limiting the area drawn.\n\
10571 \n\
10572  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10573  be in the same units as used by the Shapefile. You could use a\n\
10574  very large negative number to plot everything, but you can improve\n\
10575  performance by limiting the area drawn. The units must match those\n\
10576  of the Shapefile projection, which may be for example latitude or\n\
10577  distance. The value of miny must be less than the value of maxy.\n\
10578 \n\
10579  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10580  use a very large number to plot everything, but you can improve\n\
10581  performance by limiting the area drawn.\n\
10582 \n\
10583  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10584  zero-based indices of the Shapefile elements which will be drawn.\n\
10585  Setting\n\
10586  plotentries to NULL will plot all elements of the Shapefile.\n\
10587 \n\
10588  nplotentries (PLINT, input) : The number of items in\n\
10589  plotentries. Ignored if\n\
10590  plotentries is NULL.\n\
10591 ";
10592 static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
10593 Draw error bars in the y direction\n\
10594 \n\
10595 DESCRIPTION:\n\
10596 \n\
10597  Draws a set of n error bars in the y direction, the i\'th error bar\n\
10598  extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10599  of the error bars are of length equal to the minor tick length\n\
10600  (settable using plsmin).\n\
10601 \n\
10602  Redacted form: General: plerry(x, ymin, ymax)\n\
10603 \n\
10604 \n\
10605  This function is used in example 29.\n\
10606 \n\
10607 \n\
10608 \n\
10609 SYNOPSIS:\n\
10610 \n\
10611 plerry(n, x, ymin, ymax)\n\
10612 \n\
10613 ARGUMENTS:\n\
10614 \n\
10615  n (PLINT, input) : Number of error bars to draw.\n\
10616 \n\
10617  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10618  the error bars.\n\
10619 \n\
10620  ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10621  of the lower endpoints of the error bars.\n\
10622 \n\
10623  ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10624  of the upper endpoints of the error bars.\n\
10625 ";
10626 static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
10627 Set FCI (font characterization integer)\n\
10628 \n\
10629 DESCRIPTION:\n\
10630 \n\
10631  Sets font characteristics to be used at the start of the next string\n\
10632  using the FCI approach. See the PLplot documentation for more\n\
10633  information. Note, plsfont (which calls plsfci internally) provides a\n\
10634  more user-friendly API for setting the font characterisitics.\n\
10635 \n\
10636  Redacted form: General: plsfci(fci)\n\
10637 \n\
10638 \n\
10639  This function is used in example 23.\n\
10640 \n\
10641 \n\
10642 \n\
10643 SYNOPSIS:\n\
10644 \n\
10645 plsfci(fci)\n\
10646 \n\
10647 ARGUMENTS:\n\
10648 \n\
10649  fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10650  of FCI.\n\
10651 ";
10652 static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
10653 Select area fill pattern\n\
10654 \n\
10655 DESCRIPTION:\n\
10656 \n\
10657  If\n\
10658  patt is zero or less use either a hardware solid fill if the drivers\n\
10659  have that capability (virtually all do) or fall back to a software\n\
10660  emulation of a solid fill using the eighth area line fill pattern. If\n\
10661  0 <\n\
10662  patt <= 8, then select one of eight predefined area line fill patterns\n\
10663  to use (see plpat if you desire other patterns).\n\
10664 \n\
10665  Redacted form: plpsty(patt)\n\
10666 \n\
10667  This function is used in examples 12, 13, 15, 16, and 25.\n\
10668 \n\
10669 \n\
10670 \n\
10671 SYNOPSIS:\n\
10672 \n\
10673 plpsty(patt)\n\
10674 \n\
10675 ARGUMENTS:\n\
10676 \n\
10677  patt (PLINT, input) : The desired pattern index. If\n\
10678  patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10679  above) used. For\n\
10680  patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10681  line fill capability itself (most deliberately do not so that line\n\
10682  fill patterns look identical for those drivers), the patterns\n\
10683  consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10684  45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10685  lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10686  (8) lines at both 45 degrees and -45 degrees.\n\
10687 ";
10688 static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
10689 Set symbol size\n\
10690 \n\
10691 DESCRIPTION:\n\
10692 \n\
10693  This sets up the size of all subsequent symbols drawn by plpoin and\n\
10694  plsym. The actual height of a symbol is the product of the default\n\
10695  symbol size and a scaling factor as for the character height.\n\
10696 \n\
10697  Redacted form: plssym(def, scale)\n\
10698 \n\
10699  This function is used in example 29.\n\
10700 \n\
10701 \n\
10702 \n\
10703 SYNOPSIS:\n\
10704 \n\
10705 plssym(def, scale)\n\
10706 \n\
10707 ARGUMENTS:\n\
10708 \n\
10709  def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10710  should be set to zero if the default height is to remain\n\
10711  unchanged.\n\
10712 \n\
10713  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10714  actual symbol height.\n\
10715 ";
10716 static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
10717 Initialization\n\
10718 \n\
10719 DESCRIPTION:\n\
10720 \n\
10721  Alternative to plstar for initializing the plotting package. The\n\
10722  device name keyword for the desired output device must be supplied as\n\
10723  an argument. These keywords are the same as those printed out by\n\
10724  plstar. If the requested device is not available, or if the input\n\
10725  string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10726  is used. This routine also divides the output device page into nx by\n\
10727  ny subpages, each of which may be used independently. The subroutine\n\
10728  pladv is used to advance from one subpage to the next.\n\
10729 \n\
10730  Redacted form: General: plstart(devname, nx, ny)\n\
10731 \n\
10732 \n\
10733  This function is not used in any examples.\n\
10734 \n\
10735 \n\
10736 \n\
10737 SYNOPSIS:\n\
10738 \n\
10739 plstart(devname, nx, ny)\n\
10740 \n\
10741 ARGUMENTS:\n\
10742 \n\
10743  devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10744  containing the device name keyword of the required output device.\n\
10745  If\n\
10746  devname is NULL or if the first character of the string is a ``?\'\',\n\
10747  the normal (prompted) start up is used.\n\
10748 \n\
10749  nx (PLINT, input) : Number of subpages to divide output page in the\n\
10750  x direction.\n\
10751 \n\
10752  ny (PLINT, input) : Number of subpages to divide output page in the\n\
10753  y direction.\n\
10754 ";
10755 
10756 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10757  PLINT arg1 ;
10758  PLINT *arg2 = (PLINT *) 0 ;
10759  char **arg3 = (char **) 0 ;
10760  Matrix temp1 ;
10761  octave_value_list _out;
10762  octave_value_list *_outp=&_out;
10763  octave_value _outv;
10764 
10765  if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10766  SWIG_fail;
10767  }
10768  {
10769  if ( _n_dims( args(0) ) > 1 )
10770  {
10771  error( "argument must be a scalar or vector" ); SWIG_fail;
10772  }
10773  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10774  arg2 = new PLINT[Alen];
10775  temp1 = args(0).matrix_value();
10776  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10777  }
10778  {
10779  charMatrix temp_matrix;
10780  Cell temp_cell;
10781  char *tmp_cstring;
10782  std::string str;
10783  size_t max_length = 0, non_blank_length;
10784  int i, ifcell;
10785  if ( _n_dims( args(1) ) > 2 )
10786  {
10787  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10788  }
10789 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10790  if ( !args(1).isempty() )
10791 #else
10792  if ( !args(1).is_empty() )
10793 #endif
10794  {
10795  if ( _dim( args(1), 0 ) != Alen )
10796  {
10797  error( "first dimension must be same length as previous vector" ); SWIG_fail;
10798  }
10799  arg3 = new char*[Alen];
10800 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10801  ifcell = args(1).iscell();
10802 #else
10803  ifcell = args(1).is_cell();
10804 #endif
10805  if ( ifcell )
10806  {
10807  temp_cell = args(1).cell_value();
10808  }
10809  else
10810  {
10811  temp_matrix = args(1).char_matrix_value();
10812  // Allow one extra space for null termination.
10813  max_length = _dim( args(1), 1 ) + 1;
10814  }
10815 
10816  for ( i = 0; i < Alen; i++ )
10817  {
10818  // Must copy string to "permanent" location because the string
10819  // location corresponding to tmp_cstring gets
10820  // overwritten for each iteration of loop.
10821  if ( ifcell )
10822  {
10823  if ( temp_cell.elem( i ).is_string() )
10824  {
10825  str = temp_cell.elem( i ).string_value();
10826  // leave room for null termination.
10827  max_length = str.size() + 1;
10828  tmp_cstring = (char *) str.c_str();
10829  }
10830  else
10831  {
10832  // Use null string if user attempts to pass a cell array
10833  // with a non-string element (likely an empty element
10834  // since that should be allowed by the PLplot interface
10835  // if that element is going to be unused).
10836  // leave room for null termination.
10837  max_length = 1;
10838  tmp_cstring = (char *) "";
10839  }
10840  }
10841  else
10842  {
10843  str = temp_matrix.row_as_string( i );
10844  tmp_cstring = (char *) str.c_str();
10845  }
10846  arg3[i] = new char[max_length];
10847  strncpy( arg3[i], tmp_cstring, max_length - 1 );
10848  arg3[i][max_length - 1] = '\0';
10849  // All the trailing blank crapola should not be needed for
10850  // string cell arrays.
10851  if ( !ifcell )
10852  {
10853  // remove trailing-blank padding that is used by the
10854  // charMatrix class to insure all strings in a given
10855  // charMatrix instance have the same length.
10856  // This transformation also removes legitimate trailing
10857  // blanks but there is nothing we can do about that
10858  // for the charMatrix class.
10859 
10860  // Look for trailing nulls first (just in case, although that
10861  // shouldn't happen if charMatrix implemented as documented)
10862  // before looking for trailing blanks.
10863  non_blank_length = max_length - 2;
10864  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
10865  {
10866  non_blank_length--;
10867  }
10868  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
10869  {
10870  non_blank_length--;
10871  }
10872  arg3[i][non_blank_length + 1] = '\0';
10873  }
10874  }
10875  }
10876  else
10877  {
10878  arg3 = NULL;
10879  }
10880  }
10881  testppchar(arg1,(int const *)arg2,(char const **)arg3);
10882  _outv = octave_value();
10883  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10884  {
10885  delete [] arg2;
10886  }
10887  {
10888  int i;
10889  if ( arg3 != NULL )
10890  {
10891  for ( i = 0; i < Alen; i++ )
10892  {
10893  delete[] arg3[i];
10894  }
10895  delete[] arg3;
10896  }
10897  }
10898  return _out;
10899 fail:
10900  {
10901  delete [] arg2;
10902  }
10903  {
10904  int i;
10905  if ( arg3 != NULL )
10906  {
10907  for ( i = 0; i < Alen; i++ )
10908  {
10909  delete[] arg3[i];
10910  }
10911  delete[] arg3;
10912  }
10913  }
10914  return octave_value_list();
10915 }
10916 
10917 
10919  int *arg1 = (int *) 0 ;
10920  int *arg2 = (int *) 0 ;
10921  int *arg3 = (int *) 0 ;
10922  char *arg4 = (char *) 0 ;
10923  int *arg5 = (int *) 0 ;
10924  int *arg6 = (int *) 0 ;
10925  PLFLT *arg7 = (PLFLT *) 0 ;
10926  PLFLT *arg8 = (PLFLT *) 0 ;
10927  PLFLT *arg9 = (PLFLT *) 0 ;
10928  PLFLT *arg10 = (PLFLT *) 0 ;
10929  int *arg11 = (int *) 0 ;
10930  int temp1 ;
10931  int res1 = SWIG_TMPOBJ ;
10932  int temp2 ;
10933  int res2 = SWIG_TMPOBJ ;
10934  int temp3 ;
10935  int res3 = SWIG_TMPOBJ ;
10936  char local_string4[80] ;
10937  int temp5 ;
10938  int res5 = SWIG_TMPOBJ ;
10939  int temp6 ;
10940  int res6 = SWIG_TMPOBJ ;
10941  PLFLT temp7 ;
10942  int res7 = SWIG_TMPOBJ ;
10943  PLFLT temp8 ;
10944  int res8 = SWIG_TMPOBJ ;
10945  PLFLT temp9 ;
10946  int res9 = SWIG_TMPOBJ ;
10947  PLFLT temp10 ;
10948  int res10 = SWIG_TMPOBJ ;
10949  int temp11 ;
10950  int res11 = SWIG_TMPOBJ ;
10951  size_t local_string_length4 ;
10952  charMatrix local_charMatrix4 ;
10953  octave_value_list retval4 ;
10954  octave_value_list _out;
10955  octave_value_list *_outp=&_out;
10956  octave_value _outv;
10957  int result;
10958 
10959  arg1 = &temp1;
10960  arg2 = &temp2;
10961  arg3 = &temp3;
10962  {
10963  arg4 = local_string4;
10964  }
10965  arg5 = &temp5;
10966  arg6 = &temp6;
10967  arg7 = &temp7;
10968  arg8 = &temp8;
10969  arg9 = &temp9;
10970  arg10 = &temp10;
10971  arg11 = &temp11;
10972  if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
10973  SWIG_fail;
10974  }
10975  result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
10976  _outv = SWIG_From_int(static_cast< int >(result));
10977  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10978  if (SWIG_IsTmpObj(res1)) {
10979  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
10980  } else {
10981  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10982  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
10983  }
10984  if (SWIG_IsTmpObj(res2)) {
10985  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
10986  } else {
10987  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10988  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
10989  }
10990  if (SWIG_IsTmpObj(res3)) {
10991  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
10992  } else {
10993  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10994  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
10995  }
10996  {
10997  local_string_length4 = strlen( local_string4 );
10998  local_charMatrix4 = charMatrix( 1, local_string_length4 );
10999  local_charMatrix4.insert( local_string4, 0, 0 );
11000  retval4( 0 ) = octave_value( local_charMatrix4 );
11001  _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
11002  }
11003  if (SWIG_IsTmpObj(res5)) {
11004  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11005  } else {
11006  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11007  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11008  }
11009  if (SWIG_IsTmpObj(res6)) {
11010  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11011  } else {
11012  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11013  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11014  }
11015  if (SWIG_IsTmpObj(res7)) {
11016  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11017  } else {
11018  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11019  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11020  }
11021  if (SWIG_IsTmpObj(res8)) {
11022  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11023  } else {
11024  int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11025  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11026  }
11027  if (SWIG_IsTmpObj(res9)) {
11028  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11029  } else {
11030  int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11031  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11032  }
11033  if (SWIG_IsTmpObj(res10)) {
11034  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11035  } else {
11036  int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11037  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11038  }
11039  if (SWIG_IsTmpObj(res11)) {
11040  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11041  } else {
11042  int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11043  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11044  }
11045  return _out;
11046 fail:
11047  return octave_value_list();
11048 }
11049 
11050 
11051 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11052  PLFLT *arg1 = (PLFLT *) 0 ;
11053  PLFLT *arg2 = (PLFLT *) 0 ;
11054  PLFLT arg3 ;
11055  PLFLT arg4 ;
11056  PLFLT temp1 ;
11057  int res1 = SWIG_TMPOBJ ;
11058  PLFLT temp2 ;
11059  int res2 = SWIG_TMPOBJ ;
11060  double val3 ;
11061  int ecode3 = 0 ;
11062  double val4 ;
11063  int ecode4 = 0 ;
11064  octave_value_list _out;
11065  octave_value_list *_outp=&_out;
11066  octave_value _outv;
11067  int result;
11068 
11069  arg1 = &temp1;
11070  arg2 = &temp2;
11071  if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11072  SWIG_fail;
11073  }
11074  ecode3 = SWIG_AsVal_double(args(0), &val3);
11075  if (!SWIG_IsOK(ecode3)) {
11076  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11077  }
11078  arg3 = static_cast< PLFLT >(val3);
11079  ecode4 = SWIG_AsVal_double(args(1), &val4);
11080  if (!SWIG_IsOK(ecode4)) {
11081  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11082  }
11083  arg4 = static_cast< PLFLT >(val4);
11084  result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11085  _outv = SWIG_From_int(static_cast< int >(result));
11086  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11087  if (SWIG_IsTmpObj(res1)) {
11088  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11089  } else {
11090  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11091  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11092  }
11093  if (SWIG_IsTmpObj(res2)) {
11094  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11095  } else {
11096  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11097  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11098  }
11099  return _out;
11100 fail:
11101  return octave_value_list();
11102 }
11103 
11104 
11106  PLINT *arg1 = (PLINT *) 0 ;
11107  char *arg2 = (char *) 0 ;
11108  char *arg3 = (char *) 0 ;
11109  PLFLT arg4 ;
11110  PLFLT arg5 ;
11111  PLFLT arg6 ;
11112  PLFLT arg7 ;
11113  PLFLT arg8 ;
11114  PLFLT arg9 ;
11115  PLFLT arg10 ;
11116  PLBOOL arg11 ;
11117  PLBOOL arg12 ;
11118  PLINT arg13 ;
11119  PLINT arg14 ;
11120  PLINT *arg15 = (PLINT *) 0 ;
11121  PLINT *arg16 = (PLINT *) 0 ;
11122  char *arg17 = (char *) 0 ;
11123  char *arg18 = (char *) 0 ;
11124  char *arg19 = (char *) 0 ;
11125  char *arg20 = (char *) 0 ;
11126  char *arg21 = (char *) 0 ;
11127  char *arg22 = (char *) 0 ;
11128  char *arg23 = (char *) 0 ;
11129  PLINT temp1 ;
11130  int res1 = SWIG_TMPOBJ ;
11131  int res2 ;
11132  char *buf2 = 0 ;
11133  int alloc2 = 0 ;
11134  int res3 ;
11135  char *buf3 = 0 ;
11136  int alloc3 = 0 ;
11137  double val4 ;
11138  int ecode4 = 0 ;
11139  double val5 ;
11140  int ecode5 = 0 ;
11141  double val6 ;
11142  int ecode6 = 0 ;
11143  double val7 ;
11144  int ecode7 = 0 ;
11145  double val8 ;
11146  int ecode8 = 0 ;
11147  double val9 ;
11148  int ecode9 = 0 ;
11149  double val10 ;
11150  int ecode10 = 0 ;
11151  int val11 ;
11152  int ecode11 = 0 ;
11153  int val12 ;
11154  int ecode12 = 0 ;
11155  int val13 ;
11156  int ecode13 = 0 ;
11157  int val14 ;
11158  int ecode14 = 0 ;
11159  Matrix temp15 ;
11160  Matrix temp16 ;
11161  int res17 ;
11162  char *buf17 = 0 ;
11163  int alloc17 = 0 ;
11164  int res18 ;
11165  char *buf18 = 0 ;
11166  int alloc18 = 0 ;
11167  int res19 ;
11168  char *buf19 = 0 ;
11169  int alloc19 = 0 ;
11170  int res20 ;
11171  char *buf20 = 0 ;
11172  int alloc20 = 0 ;
11173  int res21 ;
11174  char *buf21 = 0 ;
11175  int alloc21 = 0 ;
11176  int res22 ;
11177  char *buf22 = 0 ;
11178  int alloc22 = 0 ;
11179  int res23 ;
11180  char *buf23 = 0 ;
11181  int alloc23 = 0 ;
11182  octave_value_list _out;
11183  octave_value_list *_outp=&_out;
11184  octave_value _outv;
11185 
11186  arg1 = &temp1;
11187  if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11188  SWIG_fail;
11189  }
11190  res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11191  if (!SWIG_IsOK(res2)) {
11192  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11193  }
11194  arg2 = reinterpret_cast< char * >(buf2);
11195  res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11196  if (!SWIG_IsOK(res3)) {
11197  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11198  }
11199  arg3 = reinterpret_cast< char * >(buf3);
11200  ecode4 = SWIG_AsVal_double(args(2), &val4);
11201  if (!SWIG_IsOK(ecode4)) {
11202  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11203  }
11204  arg4 = static_cast< PLFLT >(val4);
11205  ecode5 = SWIG_AsVal_double(args(3), &val5);
11206  if (!SWIG_IsOK(ecode5)) {
11207  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11208  }
11209  arg5 = static_cast< PLFLT >(val5);
11210  ecode6 = SWIG_AsVal_double(args(4), &val6);
11211  if (!SWIG_IsOK(ecode6)) {
11212  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11213  }
11214  arg6 = static_cast< PLFLT >(val6);
11215  ecode7 = SWIG_AsVal_double(args(5), &val7);
11216  if (!SWIG_IsOK(ecode7)) {
11217  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11218  }
11219  arg7 = static_cast< PLFLT >(val7);
11220  ecode8 = SWIG_AsVal_double(args(6), &val8);
11221  if (!SWIG_IsOK(ecode8)) {
11222  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11223  }
11224  arg8 = static_cast< PLFLT >(val8);
11225  ecode9 = SWIG_AsVal_double(args(7), &val9);
11226  if (!SWIG_IsOK(ecode9)) {
11227  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11228  }
11229  arg9 = static_cast< PLFLT >(val9);
11230  ecode10 = SWIG_AsVal_double(args(8), &val10);
11231  if (!SWIG_IsOK(ecode10)) {
11232  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11233  }
11234  arg10 = static_cast< PLFLT >(val10);
11235  ecode11 = SWIG_AsVal_int(args(9), &val11);
11236  if (!SWIG_IsOK(ecode11)) {
11237  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11238  }
11239  arg11 = static_cast< PLBOOL >(val11);
11240  ecode12 = SWIG_AsVal_int(args(10), &val12);
11241  if (!SWIG_IsOK(ecode12)) {
11242  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11243  }
11244  arg12 = static_cast< PLBOOL >(val12);
11245  ecode13 = SWIG_AsVal_int(args(11), &val13);
11246  if (!SWIG_IsOK(ecode13)) {
11247  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11248  }
11249  arg13 = static_cast< PLINT >(val13);
11250  ecode14 = SWIG_AsVal_int(args(12), &val14);
11251  if (!SWIG_IsOK(ecode14)) {
11252  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11253  }
11254  arg14 = static_cast< PLINT >(val14);
11255  {
11256  if ( _n_dims( args(13) ) > 1 )
11257  {
11258  error( "argument must be a scalar or vector" ); SWIG_fail;
11259  }
11260  Alen = (PLINT) ( _dim( args(13), 0 ) );
11261  temp15 = args(13).matrix_value();
11262  arg15 = new PLINT[Alen];
11263  _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11264  }
11265  {
11266  if ( _n_dims( args(14) ) > 1 )
11267  {
11268  error( "argument must be a scalar or vector" ); SWIG_fail;
11269  }
11270  if ( _dim( args(14), 0 ) != Alen )
11271  {
11272  error( "argument vectors must be same length" ); SWIG_fail;
11273  }
11274  temp16 = args(14).matrix_value();
11275  arg16 = new PLINT[Alen];
11276  _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11277  }
11278  res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11279  if (!SWIG_IsOK(res17)) {
11280  SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11281  }
11282  arg17 = reinterpret_cast< char * >(buf17);
11283  res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11284  if (!SWIG_IsOK(res18)) {
11285  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11286  }
11287  arg18 = reinterpret_cast< char * >(buf18);
11288  res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11289  if (!SWIG_IsOK(res19)) {
11290  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11291  }
11292  arg19 = reinterpret_cast< char * >(buf19);
11293  res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11294  if (!SWIG_IsOK(res20)) {
11295  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11296  }
11297  arg20 = reinterpret_cast< char * >(buf20);
11298  res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11299  if (!SWIG_IsOK(res21)) {
11300  SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11301  }
11302  arg21 = reinterpret_cast< char * >(buf21);
11303  res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11304  if (!SWIG_IsOK(res22)) {
11305  SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11306  }
11307  arg22 = reinterpret_cast< char * >(buf22);
11308  res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11309  if (!SWIG_IsOK(res23)) {
11310  SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11311  }
11312  arg23 = reinterpret_cast< char * >(buf23);
11313  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);
11314  _outv = octave_value();
11315  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11316  if (SWIG_IsTmpObj(res1)) {
11317  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11318  } else {
11319  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11320  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11321  }
11322  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11323  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11324  {
11325  delete [] arg15;
11326  }
11327  {
11328  delete [] arg16;
11329  }
11330  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11331  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11332  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11333  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11334  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11335  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11336  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11337  return _out;
11338 fail:
11339  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11340  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11341  {
11342  delete [] arg15;
11343  }
11344  {
11345  delete [] arg16;
11346  }
11347  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11348  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11349  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11350  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11351  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11352  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11353  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11354  return octave_value_list();
11355 }
11356 
11357 
11359  PLFLT *arg1 = (PLFLT *) 0 ;
11360  PLINT arg2 ;
11361  PLINT arg3 ;
11362  PLINT arg4 ;
11363  PLINT arg5 ;
11364  PLINT arg6 ;
11365  PLINT arg7 ;
11366  PLFLT *arg8 = (PLFLT *) 0 ;
11367  PLINT arg9 ;
11368  PLFLT *arg10 = (PLFLT *) 0 ;
11369  Matrix temp1 ;
11370  int val4 ;
11371  int ecode4 = 0 ;
11372  int val5 ;
11373  int ecode5 = 0 ;
11374  int val6 ;
11375  int ecode6 = 0 ;
11376  int val7 ;
11377  int ecode7 = 0 ;
11378  Matrix temp8 ;
11379  Matrix temp10 ;
11380  octave_value_list _out;
11381  octave_value_list *_outp=&_out;
11382  octave_value _outv;
11383 
11384  if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11385  SWIG_fail;
11386  }
11387  {
11388  if ( _n_dims( args(0) ) > 2 )
11389  {
11390  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11391  }
11392  temp1 = args(0).matrix_value();
11393  arg1 = &temp1( 0, 0 );
11394  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11395  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11396  }
11397  ecode4 = SWIG_AsVal_int(args(1), &val4);
11398  if (!SWIG_IsOK(ecode4)) {
11399  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11400  }
11401  arg4 = static_cast< PLINT >(val4);
11402  ecode5 = SWIG_AsVal_int(args(2), &val5);
11403  if (!SWIG_IsOK(ecode5)) {
11404  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11405  }
11406  arg5 = static_cast< PLINT >(val5);
11407  ecode6 = SWIG_AsVal_int(args(3), &val6);
11408  if (!SWIG_IsOK(ecode6)) {
11409  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11410  }
11411  arg6 = static_cast< PLINT >(val6);
11412  ecode7 = SWIG_AsVal_int(args(4), &val7);
11413  if (!SWIG_IsOK(ecode7)) {
11414  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11415  }
11416  arg7 = static_cast< PLINT >(val7);
11417  {
11418  if ( _n_dims( args(5) ) > 1 )
11419  {
11420  error( "argument must be a scalar or vector" ); SWIG_fail;
11421  }
11422  temp8 = args(5).matrix_value();
11423  arg8 = &temp8( 0, 0 );
11424  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11425  }
11426  {
11427  if ( _n_dims( args(6) ) > 1 )
11428  {
11429  error( "argument must be a scalar or vector" ); SWIG_fail;
11430  }
11431  if ( _dim( args(6), 0 ) != 6 )
11432  {
11433  error( "argument vectors must have length of 6" ); SWIG_fail;
11434  }
11435  temp10 = args(6).matrix_value();
11436  arg10 = &temp10( 0, 0 );
11437  }
11438  my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11439  _outv = octave_value();
11440  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11441  {
11442 
11443  }
11444  {
11445 
11446  }
11447  {
11448 
11449  }
11450  return _out;
11451 fail:
11452  {
11453 
11454  }
11455  {
11456 
11457  }
11458  {
11459 
11460  }
11461  return octave_value_list();
11462 }
11463 
11464 
11465 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11466  PLFLT *arg1 = (PLFLT *) 0 ;
11467  PLINT arg2 ;
11468  PLINT arg3 ;
11469  PLINT arg4 ;
11470  PLINT arg5 ;
11471  PLINT arg6 ;
11472  PLINT arg7 ;
11473  PLFLT *arg8 = (PLFLT *) 0 ;
11474  PLINT arg9 ;
11475  Matrix temp1 ;
11476  int val4 ;
11477  int ecode4 = 0 ;
11478  int val5 ;
11479  int ecode5 = 0 ;
11480  int val6 ;
11481  int ecode6 = 0 ;
11482  int val7 ;
11483  int ecode7 = 0 ;
11484  Matrix temp8 ;
11485  octave_value_list _out;
11486  octave_value_list *_outp=&_out;
11487  octave_value _outv;
11488 
11489  if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11490  SWIG_fail;
11491  }
11492  {
11493  if ( _n_dims( args(0) ) > 2 )
11494  {
11495  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11496  }
11497  temp1 = args(0).matrix_value();
11498  arg1 = &temp1( 0, 0 );
11499  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11500  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11501  }
11502  ecode4 = SWIG_AsVal_int(args(1), &val4);
11503  if (!SWIG_IsOK(ecode4)) {
11504  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11505  }
11506  arg4 = static_cast< PLINT >(val4);
11507  ecode5 = SWIG_AsVal_int(args(2), &val5);
11508  if (!SWIG_IsOK(ecode5)) {
11509  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11510  }
11511  arg5 = static_cast< PLINT >(val5);
11512  ecode6 = SWIG_AsVal_int(args(3), &val6);
11513  if (!SWIG_IsOK(ecode6)) {
11514  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11515  }
11516  arg6 = static_cast< PLINT >(val6);
11517  ecode7 = SWIG_AsVal_int(args(4), &val7);
11518  if (!SWIG_IsOK(ecode7)) {
11519  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11520  }
11521  arg7 = static_cast< PLINT >(val7);
11522  {
11523  if ( _n_dims( args(5) ) > 1 )
11524  {
11525  error( "argument must be a scalar or vector" ); SWIG_fail;
11526  }
11527  temp8 = args(5).matrix_value();
11528  arg8 = &temp8( 0, 0 );
11529  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11530  }
11531  my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11532  _outv = octave_value();
11533  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11534  {
11535 
11536  }
11537  {
11538 
11539  }
11540  return _out;
11541 fail:
11542  {
11543 
11544  }
11545  {
11546 
11547  }
11548  return octave_value_list();
11549 }
11550 
11551 
11552 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11553  PLFLT *arg1 = (PLFLT *) 0 ;
11554  PLINT arg2 ;
11555  PLINT arg3 ;
11556  PLINT arg4 ;
11557  PLINT arg5 ;
11558  PLINT arg6 ;
11559  PLINT arg7 ;
11560  PLFLT *arg8 = (PLFLT *) 0 ;
11561  PLINT arg9 ;
11562  PLFLT *arg10 = (PLFLT *) 0 ;
11563  PLFLT *arg11 = (PLFLT *) 0 ;
11564  Matrix temp1 ;
11565  int val4 ;
11566  int ecode4 = 0 ;
11567  int val5 ;
11568  int ecode5 = 0 ;
11569  int val6 ;
11570  int ecode6 = 0 ;
11571  int val7 ;
11572  int ecode7 = 0 ;
11573  Matrix temp8 ;
11574  Matrix temp10 ;
11575  Matrix temp11 ;
11576  octave_value_list _out;
11577  octave_value_list *_outp=&_out;
11578  octave_value _outv;
11579 
11580  if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11581  SWIG_fail;
11582  }
11583  {
11584  if ( _n_dims( args(0) ) > 2 )
11585  {
11586  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11587  }
11588  temp1 = args(0).matrix_value();
11589  arg1 = &temp1( 0, 0 );
11590  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11591  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11592  }
11593  ecode4 = SWIG_AsVal_int(args(1), &val4);
11594  if (!SWIG_IsOK(ecode4)) {
11595  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11596  }
11597  arg4 = static_cast< PLINT >(val4);
11598  ecode5 = SWIG_AsVal_int(args(2), &val5);
11599  if (!SWIG_IsOK(ecode5)) {
11600  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11601  }
11602  arg5 = static_cast< PLINT >(val5);
11603  ecode6 = SWIG_AsVal_int(args(3), &val6);
11604  if (!SWIG_IsOK(ecode6)) {
11605  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11606  }
11607  arg6 = static_cast< PLINT >(val6);
11608  ecode7 = SWIG_AsVal_int(args(4), &val7);
11609  if (!SWIG_IsOK(ecode7)) {
11610  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11611  }
11612  arg7 = static_cast< PLINT >(val7);
11613  {
11614  if ( _n_dims( args(5) ) > 1 )
11615  {
11616  error( "argument must be a scalar or vector" ); SWIG_fail;
11617  }
11618  temp8 = args(5).matrix_value();
11619  arg8 = &temp8( 0, 0 );
11620  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11621  }
11622  {
11623  if ( _n_dims( args(6) ) > 1 )
11624  {
11625  error( "argument must be a scalar or vector" ); SWIG_fail;
11626  }
11627  if ( _dim( args(6), 0 ) != Xlen )
11628  {
11629  error( "argument vectors must be same length" ); SWIG_fail;
11630  }
11631  temp10 = args(6).matrix_value();
11632  arg10 = &temp10( 0, 0 );
11633  }
11634  {
11635  if ( _n_dims( args(7) ) > 1 )
11636  {
11637  error( "argument must be a scalar or vector" ); SWIG_fail;
11638  }
11639  if ( _dim( args(7), 0 ) != Ylen )
11640  {
11641  error( "argument vectors must be same length" ); SWIG_fail;
11642  }
11643  temp11 = args(7).matrix_value();
11644  arg11 = &temp11( 0, 0 );
11645  }
11646  my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11647  _outv = octave_value();
11648  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11649  {
11650 
11651  }
11652  {
11653 
11654  }
11655  {
11656 
11657  }
11658  {
11659 
11660  }
11661  return _out;
11662 fail:
11663  {
11664 
11665  }
11666  {
11667 
11668  }
11669  {
11670 
11671  }
11672  {
11673 
11674  }
11675  return octave_value_list();
11676 }
11677 
11678 
11679 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
11680  PLFLT *arg1 = (PLFLT *) 0 ;
11681  PLINT arg2 ;
11682  PLINT arg3 ;
11683  PLINT arg4 ;
11684  PLINT arg5 ;
11685  PLINT arg6 ;
11686  PLINT arg7 ;
11687  PLFLT *arg8 = (PLFLT *) 0 ;
11688  PLINT arg9 ;
11689  PLFLT *arg10 = (PLFLT *) 0 ;
11690  PLFLT *arg11 = (PLFLT *) 0 ;
11691  Matrix temp1 ;
11692  int val4 ;
11693  int ecode4 = 0 ;
11694  int val5 ;
11695  int ecode5 = 0 ;
11696  int val6 ;
11697  int ecode6 = 0 ;
11698  int val7 ;
11699  int ecode7 = 0 ;
11700  Matrix temp8 ;
11701  Matrix temp10 ;
11702  Matrix temp11 ;
11703  octave_value_list _out;
11704  octave_value_list *_outp=&_out;
11705  octave_value _outv;
11706 
11707  if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11708  SWIG_fail;
11709  }
11710  {
11711  if ( _n_dims( args(0) ) > 2 )
11712  {
11713  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11714  }
11715  temp1 = args(0).matrix_value();
11716  arg1 = &temp1( 0, 0 );
11717  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11718  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11719  }
11720  ecode4 = SWIG_AsVal_int(args(1), &val4);
11721  if (!SWIG_IsOK(ecode4)) {
11722  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11723  }
11724  arg4 = static_cast< PLINT >(val4);
11725  ecode5 = SWIG_AsVal_int(args(2), &val5);
11726  if (!SWIG_IsOK(ecode5)) {
11727  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11728  }
11729  arg5 = static_cast< PLINT >(val5);
11730  ecode6 = SWIG_AsVal_int(args(3), &val6);
11731  if (!SWIG_IsOK(ecode6)) {
11732  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
11733  }
11734  arg6 = static_cast< PLINT >(val6);
11735  ecode7 = SWIG_AsVal_int(args(4), &val7);
11736  if (!SWIG_IsOK(ecode7)) {
11737  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
11738  }
11739  arg7 = static_cast< PLINT >(val7);
11740  {
11741  if ( _n_dims( args(5) ) > 1 )
11742  {
11743  error( "argument must be a scalar or vector" ); SWIG_fail;
11744  }
11745  temp8 = args(5).matrix_value();
11746  arg8 = &temp8( 0, 0 );
11747  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11748  }
11749  {
11750  if ( _n_dims( args(6) ) > 2 )
11751  {
11752  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11753  }
11754  if ( _dim( args(6), 0 ) != Xlen )
11755  {
11756  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11757  }
11758  if ( _dim( args(6), 1 ) != Ylen )
11759  {
11760  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11761  }
11762  temp10 = args(6).matrix_value();
11763  arg10 = &temp10( 0, 0 );
11764  }
11765  {
11766  if ( _n_dims( args(7) ) > 2 )
11767  {
11768  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11769  }
11770  if ( _dim( args(7), 0 ) != Xlen )
11771  {
11772  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11773  }
11774  if ( _dim( args(7), 1 ) != Ylen )
11775  {
11776  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11777  }
11778  temp11 = args(7).matrix_value();
11779  arg11 = &temp11( 0, 0 );
11780  }
11781  my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11782  _outv = octave_value();
11783  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11784  {
11785 
11786  }
11787  {
11788 
11789  }
11790  {
11791 
11792  }
11793  {
11794 
11795  }
11796  return _out;
11797 fail:
11798  {
11799 
11800  }
11801  {
11802 
11803  }
11804  {
11805 
11806  }
11807  {
11808 
11809  }
11810  return octave_value_list();
11811 }
11812 
11813 
11814 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
11815  PLFLT *arg1 = (PLFLT *) 0 ;
11816  PLINT arg2 ;
11817  PLINT arg3 ;
11818  PLINT arg4 ;
11819  PLINT arg5 ;
11820  PLINT arg6 ;
11821  PLINT arg7 ;
11822  PLFLT *arg8 = (PLFLT *) 0 ;
11823  PLINT arg9 ;
11824  PLFLT *arg10 = (PLFLT *) 0 ;
11825  PLFLT *arg11 = (PLFLT *) 0 ;
11826  Matrix temp1 ;
11827  int val4 ;
11828  int ecode4 = 0 ;
11829  int val5 ;
11830  int ecode5 = 0 ;
11831  int val6 ;
11832  int ecode6 = 0 ;
11833  int val7 ;
11834  int ecode7 = 0 ;
11835  Matrix temp8 ;
11836  Matrix temp10 ;
11837  Matrix temp11 ;
11838  octave_value_list _out;
11839  octave_value_list *_outp=&_out;
11840  octave_value _outv;
11841 
11842  if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
11843  SWIG_fail;
11844  }
11845  {
11846  if ( _n_dims( args(0) ) > 2 )
11847  {
11848  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11849  }
11850  temp1 = args(0).matrix_value();
11851  arg1 = &temp1( 0, 0 );
11852  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11853  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11854  }
11855  ecode4 = SWIG_AsVal_int(args(1), &val4);
11856  if (!SWIG_IsOK(ecode4)) {
11857  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
11858  }
11859  arg4 = static_cast< PLINT >(val4);
11860  ecode5 = SWIG_AsVal_int(args(2), &val5);
11861  if (!SWIG_IsOK(ecode5)) {
11862  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
11863  }
11864  arg5 = static_cast< PLINT >(val5);
11865  ecode6 = SWIG_AsVal_int(args(3), &val6);
11866  if (!SWIG_IsOK(ecode6)) {
11867  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
11868  }
11869  arg6 = static_cast< PLINT >(val6);
11870  ecode7 = SWIG_AsVal_int(args(4), &val7);
11871  if (!SWIG_IsOK(ecode7)) {
11872  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
11873  }
11874  arg7 = static_cast< PLINT >(val7);
11875  {
11876  if ( _n_dims( args(5) ) > 1 )
11877  {
11878  error( "argument must be a scalar or vector" ); SWIG_fail;
11879  }
11880  temp8 = args(5).matrix_value();
11881  arg8 = &temp8( 0, 0 );
11882  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11883  }
11884  {
11885  if ( _n_dims( args(6) ) > 2 )
11886  {
11887  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11888  }
11889  if ( _dim( args(6), 0 ) != Xlen )
11890  {
11891  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11892  }
11893  if ( _dim( args(6), 1 ) != Ylen )
11894  {
11895  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11896  }
11897  temp10 = args(6).matrix_value();
11898  arg10 = &temp10( 0, 0 );
11899  }
11900  {
11901  if ( _n_dims( args(7) ) > 2 )
11902  {
11903  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11904  }
11905  if ( _dim( args(7), 0 ) != Xlen )
11906  {
11907  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11908  }
11909  if ( _dim( args(7), 1 ) != Ylen )
11910  {
11911  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11912  }
11913  temp11 = args(7).matrix_value();
11914  arg11 = &temp11( 0, 0 );
11915  }
11916  my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11917  _outv = octave_value();
11918  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11919  {
11920 
11921  }
11922  {
11923 
11924  }
11925  {
11926 
11927  }
11928  {
11929 
11930  }
11931  return _out;
11932 fail:
11933  {
11934 
11935  }
11936  {
11937 
11938  }
11939  {
11940 
11941  }
11942  {
11943 
11944  }
11945  return octave_value_list();
11946 }
11947 
11948 
11950  PLFLT *arg1 = (PLFLT *) 0 ;
11951  PLFLT *arg2 = (PLFLT *) 0 ;
11952  PLFLT *arg3 = (PLFLT *) 0 ;
11953  PLINT arg4 ;
11954  PLFLT *arg5 = (PLFLT *) 0 ;
11955  PLINT arg6 ;
11956  PLFLT *arg7 = (PLFLT *) 0 ;
11957  PLINT arg8 ;
11958  PLFLT *arg9 = (PLFLT *) 0 ;
11959  PLINT arg10 ;
11960  PLFLT arg11 ;
11961  Matrix temp1 ;
11962  Matrix temp2 ;
11963  Matrix temp3 ;
11964  Matrix temp5 ;
11965  Matrix temp7 ;
11966  octave_value_list retval7 ;
11967  int val10 ;
11968  int ecode10 = 0 ;
11969  double val11 ;
11970  int ecode11 = 0 ;
11971  octave_value_list _out;
11972  octave_value_list *_outp=&_out;
11973  octave_value _outv;
11974 
11975  if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
11976  SWIG_fail;
11977  }
11978  {
11979  if ( _n_dims( args(0) ) > 1 )
11980  {
11981  error( "argument must be a scalar or vector" ); SWIG_fail;
11982  }
11983  Alen = (PLINT) ( _dim( args(0), 0 ) );
11984  temp1 = args(0).matrix_value();
11985  arg1 = &temp1( 0, 0 );
11986  }
11987  {
11988  if ( _n_dims( args(1) ) > 1 )
11989  {
11990  error( "argument must be a scalar or vector" ); SWIG_fail;
11991  }
11992  if ( _dim( args(1), 0 ) != Alen )
11993  {
11994  error( "argument vectors must be same length" ); SWIG_fail;
11995  }
11996  temp2 = args(1).matrix_value();
11997  arg2 = &temp2( 0, 0 );
11998  }
11999  {
12000  if ( _n_dims( args(2) ) > 1 )
12001  {
12002  error( "argument must be a scalar or vector" ); SWIG_fail;
12003  }
12004  if ( _dim( args(2), 0 ) != Alen )
12005  {
12006  error( "argument vectors must be same length" ); SWIG_fail;
12007  }
12008  temp3 = args(2).matrix_value();
12009  arg3 = &temp3( 0, 0 );
12010  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12011  }
12012  {
12013  if ( _n_dims( args(3) ) > 1 )
12014  {
12015  error( "argument must be a scalar or vector" ); SWIG_fail;
12016  }
12017  temp5 = args(3).matrix_value();
12018  arg5 = &temp5( 0, 0 );
12019  arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12020  }
12021  {
12022  if ( _n_dims( args(4) ) > 1 )
12023  {
12024  error( "argument must be a scalar or vector" ); SWIG_fail;
12025  }
12026  temp7 = args(4).matrix_value();
12027  arg7 = &temp7( 0, 0 );
12028  arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12029  retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12030  arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12031  }
12032  ecode10 = SWIG_AsVal_int(args(5), &val10);
12033  if (!SWIG_IsOK(ecode10)) {
12034  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12035  }
12036  arg10 = static_cast< PLINT >(val10);
12037  ecode11 = SWIG_AsVal_double(args(6), &val11);
12038  if (!SWIG_IsOK(ecode11)) {
12039  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12040  }
12041  arg11 = static_cast< PLFLT >(val11);
12042  my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12043  _outv = octave_value();
12044  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12045  {
12046  _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
12047  }
12048  {
12049 
12050  }
12051  {
12052 
12053  }
12054  {
12055 
12056  }
12057  {
12058 
12059  }
12060  {
12061 
12062  }
12063  return _out;
12064 fail:
12065  {
12066 
12067  }
12068  {
12069 
12070  }
12071  {
12072 
12073  }
12074  {
12075 
12076  }
12077  {
12078 
12079  }
12080  return octave_value_list();
12081 }
12082 
12083 
12085  PLFLT *arg1 = (PLFLT *) 0 ;
12086  PLFLT *arg2 = (PLFLT *) 0 ;
12087  PLFLT *arg3 = (PLFLT *) 0 ;
12088  PLINT arg4 ;
12089  PLINT arg5 ;
12090  PLINT arg6 ;
12091  Matrix temp1 ;
12092  Matrix temp2 ;
12093  Matrix temp3 ;
12094  int val6 ;
12095  int ecode6 = 0 ;
12096  octave_value_list _out;
12097  octave_value_list *_outp=&_out;
12098  octave_value _outv;
12099 
12100  if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12101  SWIG_fail;
12102  }
12103  {
12104  if ( _n_dims( args(0) ) > 1 )
12105  {
12106  error( "argument must be a scalar or vector" ); SWIG_fail;
12107  }
12108  temp1 = args(0).matrix_value();
12109  arg1 = &temp1( 0, 0 );
12110  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12111  }
12112  {
12113  if ( _n_dims( args(1) ) > 1 )
12114  {
12115  error( "argument must be a scalar or vector" ); SWIG_fail;
12116  }
12117  temp2 = args(1).matrix_value();
12118  arg2 = &temp2( 0, 0 );
12119  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12120  }
12121  {
12122  if ( _n_dims( args(2) ) > 2 )
12123  {
12124  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12125  }
12126  if ( _dim( args(2), 0 ) != Xlen )
12127  {
12128  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12129  }
12130  if ( _dim( args(2), 1 ) != Ylen )
12131  {
12132  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12133  }
12134  temp3 = args(2).matrix_value();
12135  arg3 = &temp3( 0, 0 );
12136  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12137  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12138  }
12139  ecode6 = SWIG_AsVal_int(args(3), &val6);
12140  if (!SWIG_IsOK(ecode6)) {
12141  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12142  }
12143  arg6 = static_cast< PLINT >(val6);
12144  my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12145  _outv = octave_value();
12146  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12147  {
12148 
12149  }
12150  {
12151 
12152  }
12153  {
12154 
12155  }
12156  return _out;
12157 fail:
12158  {
12159 
12160  }
12161  {
12162 
12163  }
12164  {
12165 
12166  }
12167  return octave_value_list();
12168 }
12169 
12170 
12172  PLFLT *arg1 = (PLFLT *) 0 ;
12173  PLFLT *arg2 = (PLFLT *) 0 ;
12174  PLFLT *arg3 = (PLFLT *) 0 ;
12175  PLINT arg4 ;
12176  PLINT arg5 ;
12177  PLINT arg6 ;
12178  PLFLT *arg7 = (PLFLT *) 0 ;
12179  PLINT arg8 ;
12180  Matrix temp1 ;
12181  Matrix temp2 ;
12182  Matrix temp3 ;
12183  int val6 ;
12184  int ecode6 = 0 ;
12185  Matrix temp7 ;
12186  octave_value_list _out;
12187  octave_value_list *_outp=&_out;
12188  octave_value _outv;
12189 
12190  if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12191  SWIG_fail;
12192  }
12193  {
12194  if ( _n_dims( args(0) ) > 1 )
12195  {
12196  error( "argument must be a scalar or vector" ); SWIG_fail;
12197  }
12198  temp1 = args(0).matrix_value();
12199  arg1 = &temp1( 0, 0 );
12200  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12201  }
12202  {
12203  if ( _n_dims( args(1) ) > 1 )
12204  {
12205  error( "argument must be a scalar or vector" ); SWIG_fail;
12206  }
12207  temp2 = args(1).matrix_value();
12208  arg2 = &temp2( 0, 0 );
12209  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12210  }
12211  {
12212  if ( _n_dims( args(2) ) > 2 )
12213  {
12214  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12215  }
12216  if ( _dim( args(2), 0 ) != Xlen )
12217  {
12218  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12219  }
12220  if ( _dim( args(2), 1 ) != Ylen )
12221  {
12222  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12223  }
12224  temp3 = args(2).matrix_value();
12225  arg3 = &temp3( 0, 0 );
12226  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12227  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12228  }
12229  ecode6 = SWIG_AsVal_int(args(3), &val6);
12230  if (!SWIG_IsOK(ecode6)) {
12231  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12232  }
12233  arg6 = static_cast< PLINT >(val6);
12234  {
12235  if ( _n_dims( args(4) ) > 1 )
12236  {
12237  error( "argument must be a scalar or vector" ); SWIG_fail;
12238  }
12239  temp7 = args(4).matrix_value();
12240  arg7 = &temp7( 0, 0 );
12241  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12242  }
12243  my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12244  _outv = octave_value();
12245  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12246  {
12247 
12248  }
12249  {
12250 
12251  }
12252  {
12253 
12254  }
12255  {
12256 
12257  }
12258  return _out;
12259 fail:
12260  {
12261 
12262  }
12263  {
12264 
12265  }
12266  {
12267 
12268  }
12269  {
12270 
12271  }
12272  return octave_value_list();
12273 }
12274 
12275 
12277  PLFLT *arg1 = (PLFLT *) 0 ;
12278  PLFLT *arg2 = (PLFLT *) 0 ;
12279  PLFLT *arg3 = (PLFLT *) 0 ;
12280  PLINT arg4 ;
12281  PLINT arg5 ;
12282  PLINT arg6 ;
12283  PLBOOL arg7 ;
12284  Matrix temp1 ;
12285  Matrix temp2 ;
12286  Matrix temp3 ;
12287  int val6 ;
12288  int ecode6 = 0 ;
12289  int val7 ;
12290  int ecode7 = 0 ;
12291  octave_value_list _out;
12292  octave_value_list *_outp=&_out;
12293  octave_value _outv;
12294 
12295  if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12296  SWIG_fail;
12297  }
12298  {
12299  if ( _n_dims( args(0) ) > 1 )
12300  {
12301  error( "argument must be a scalar or vector" ); SWIG_fail;
12302  }
12303  temp1 = args(0).matrix_value();
12304  arg1 = &temp1( 0, 0 );
12305  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12306  }
12307  {
12308  if ( _n_dims( args(1) ) > 1 )
12309  {
12310  error( "argument must be a scalar or vector" ); SWIG_fail;
12311  }
12312  temp2 = args(1).matrix_value();
12313  arg2 = &temp2( 0, 0 );
12314  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12315  }
12316  {
12317  if ( _n_dims( args(2) ) > 2 )
12318  {
12319  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12320  }
12321  if ( _dim( args(2), 0 ) != Xlen )
12322  {
12323  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12324  }
12325  if ( _dim( args(2), 1 ) != Ylen )
12326  {
12327  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12328  }
12329  temp3 = args(2).matrix_value();
12330  arg3 = &temp3( 0, 0 );
12331  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12332  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12333  }
12334  ecode6 = SWIG_AsVal_int(args(3), &val6);
12335  if (!SWIG_IsOK(ecode6)) {
12336  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12337  }
12338  arg6 = static_cast< PLINT >(val6);
12339  ecode7 = SWIG_AsVal_int(args(4), &val7);
12340  if (!SWIG_IsOK(ecode7)) {
12341  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12342  }
12343  arg7 = static_cast< PLBOOL >(val7);
12344  my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12345  _outv = octave_value();
12346  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12347  {
12348 
12349  }
12350  {
12351 
12352  }
12353  {
12354 
12355  }
12356  return _out;
12357 fail:
12358  {
12359 
12360  }
12361  {
12362 
12363  }
12364  {
12365 
12366  }
12367  return octave_value_list();
12368 }
12369 
12370 
12372  PLFLT *arg1 = (PLFLT *) 0 ;
12373  PLFLT *arg2 = (PLFLT *) 0 ;
12374  PLFLT *arg3 = (PLFLT *) 0 ;
12375  PLINT arg4 ;
12376  PLINT arg5 ;
12377  PLINT arg6 ;
12378  PLFLT *arg7 = (PLFLT *) 0 ;
12379  PLINT arg8 ;
12380  Matrix temp1 ;
12381  Matrix temp2 ;
12382  Matrix temp3 ;
12383  int val6 ;
12384  int ecode6 = 0 ;
12385  Matrix temp7 ;
12386  octave_value_list _out;
12387  octave_value_list *_outp=&_out;
12388  octave_value _outv;
12389 
12390  if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12391  SWIG_fail;
12392  }
12393  {
12394  if ( _n_dims( args(0) ) > 1 )
12395  {
12396  error( "argument must be a scalar or vector" ); SWIG_fail;
12397  }
12398  temp1 = args(0).matrix_value();
12399  arg1 = &temp1( 0, 0 );
12400  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12401  }
12402  {
12403  if ( _n_dims( args(1) ) > 1 )
12404  {
12405  error( "argument must be a scalar or vector" ); SWIG_fail;
12406  }
12407  temp2 = args(1).matrix_value();
12408  arg2 = &temp2( 0, 0 );
12409  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12410  }
12411  {
12412  if ( _n_dims( args(2) ) > 2 )
12413  {
12414  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12415  }
12416  if ( _dim( args(2), 0 ) != Xlen )
12417  {
12418  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12419  }
12420  if ( _dim( args(2), 1 ) != Ylen )
12421  {
12422  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12423  }
12424  temp3 = args(2).matrix_value();
12425  arg3 = &temp3( 0, 0 );
12426  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12427  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12428  }
12429  ecode6 = SWIG_AsVal_int(args(3), &val6);
12430  if (!SWIG_IsOK(ecode6)) {
12431  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12432  }
12433  arg6 = static_cast< PLINT >(val6);
12434  {
12435  if ( _n_dims( args(4) ) > 1 )
12436  {
12437  error( "argument must be a scalar or vector" ); SWIG_fail;
12438  }
12439  temp7 = args(4).matrix_value();
12440  arg7 = &temp7( 0, 0 );
12441  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12442  }
12443  my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12444  _outv = octave_value();
12445  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12446  {
12447 
12448  }
12449  {
12450 
12451  }
12452  {
12453 
12454  }
12455  {
12456 
12457  }
12458  return _out;
12459 fail:
12460  {
12461 
12462  }
12463  {
12464 
12465  }
12466  {
12467 
12468  }
12469  {
12470 
12471  }
12472  return octave_value_list();
12473 }
12474 
12475 
12477  PLFLT *arg1 = (PLFLT *) 0 ;
12478  PLFLT *arg2 = (PLFLT *) 0 ;
12479  PLFLT *arg3 = (PLFLT *) 0 ;
12480  PLINT arg4 ;
12481  PLINT arg5 ;
12482  PLINT arg6 ;
12483  PLFLT *arg7 = (PLFLT *) 0 ;
12484  PLINT arg8 ;
12485  PLINT arg9 ;
12486  PLINT arg10 ;
12487  PLINT *arg11 = (PLINT *) 0 ;
12488  PLINT *arg12 = (PLINT *) 0 ;
12489  Matrix temp1 ;
12490  Matrix temp2 ;
12491  Matrix temp3 ;
12492  int val6 ;
12493  int ecode6 = 0 ;
12494  Matrix temp7 ;
12495  int val9 ;
12496  int ecode9 = 0 ;
12497  Matrix temp10 ;
12498  Matrix temp12 ;
12499  octave_value_list _out;
12500  octave_value_list *_outp=&_out;
12501  octave_value _outv;
12502 
12503  if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12504  SWIG_fail;
12505  }
12506  {
12507  if ( _n_dims( args(0) ) > 1 )
12508  {
12509  error( "argument must be a scalar or vector" ); SWIG_fail;
12510  }
12511  temp1 = args(0).matrix_value();
12512  arg1 = &temp1( 0, 0 );
12513  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12514  }
12515  {
12516  if ( _n_dims( args(1) ) > 1 )
12517  {
12518  error( "argument must be a scalar or vector" ); SWIG_fail;
12519  }
12520  temp2 = args(1).matrix_value();
12521  arg2 = &temp2( 0, 0 );
12522  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12523  }
12524  {
12525  if ( _n_dims( args(2) ) > 2 )
12526  {
12527  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12528  }
12529  if ( _dim( args(2), 0 ) != Xlen )
12530  {
12531  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12532  }
12533  if ( _dim( args(2), 1 ) != Ylen )
12534  {
12535  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12536  }
12537  temp3 = args(2).matrix_value();
12538  arg3 = &temp3( 0, 0 );
12539  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12540  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12541  }
12542  ecode6 = SWIG_AsVal_int(args(3), &val6);
12543  if (!SWIG_IsOK(ecode6)) {
12544  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
12545  }
12546  arg6 = static_cast< PLINT >(val6);
12547  {
12548  if ( _n_dims( args(4) ) > 1 )
12549  {
12550  error( "argument must be a scalar or vector" ); SWIG_fail;
12551  }
12552  temp7 = args(4).matrix_value();
12553  arg7 = &temp7( 0, 0 );
12554  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12555  }
12556  ecode9 = SWIG_AsVal_int(args(5), &val9);
12557  if (!SWIG_IsOK(ecode9)) {
12558  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
12559  }
12560  arg9 = static_cast< PLINT >(val9);
12561  {
12562  if ( _n_dims( args(6) ) > 1 )
12563  {
12564  error( "argument must be a scalar or vector" ); SWIG_fail;
12565  }
12566  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12567  arg11 = new PLINT[Alen];
12568  temp10 = args(6).matrix_value();
12569  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12570  }
12571  {
12572  if ( _n_dims( args(7) ) > 1 )
12573  {
12574  error( "argument must be a scalar or vector" ); SWIG_fail;
12575  }
12576  if ( _dim( args(7), 0 ) != Alen )
12577  {
12578  error( "argument vectors must be same length" ); SWIG_fail;
12579  }
12580  temp12 = args(7).matrix_value();
12581  arg12 = new PLINT[Alen];
12582  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12583  }
12584  my_plot3dcl((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
12585  _outv = octave_value();
12586  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12587  {
12588 
12589  }
12590  {
12591 
12592  }
12593  {
12594 
12595  }
12596  {
12597 
12598  }
12599  {
12600  delete [] arg11;
12601  }
12602  {
12603  delete [] arg12;
12604  }
12605  return _out;
12606 fail:
12607  {
12608 
12609  }
12610  {
12611 
12612  }
12613  {
12614 
12615  }
12616  {
12617 
12618  }
12619  {
12620  delete [] arg11;
12621  }
12622  {
12623  delete [] arg12;
12624  }
12625  return octave_value_list();
12626 }
12627 
12628 
12630  PLFLT *arg1 = (PLFLT *) 0 ;
12631  PLFLT *arg2 = (PLFLT *) 0 ;
12632  PLFLT *arg3 = (PLFLT *) 0 ;
12633  PLINT arg4 ;
12634  PLINT arg5 ;
12635  PLINT arg6 ;
12636  PLFLT *arg7 = (PLFLT *) 0 ;
12637  PLINT arg8 ;
12638  Matrix temp1 ;
12639  Matrix temp2 ;
12640  Matrix temp3 ;
12641  int val6 ;
12642  int ecode6 = 0 ;
12643  Matrix temp7 ;
12644  octave_value_list _out;
12645  octave_value_list *_outp=&_out;
12646  octave_value _outv;
12647 
12648  if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
12649  SWIG_fail;
12650  }
12651  {
12652  if ( _n_dims( args(0) ) > 1 )
12653  {
12654  error( "argument must be a scalar or vector" ); SWIG_fail;
12655  }
12656  temp1 = args(0).matrix_value();
12657  arg1 = &temp1( 0, 0 );
12658  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12659  }
12660  {
12661  if ( _n_dims( args(1) ) > 1 )
12662  {
12663  error( "argument must be a scalar or vector" ); SWIG_fail;
12664  }
12665  temp2 = args(1).matrix_value();
12666  arg2 = &temp2( 0, 0 );
12667  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12668  }
12669  {
12670  if ( _n_dims( args(2) ) > 2 )
12671  {
12672  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12673  }
12674  if ( _dim( args(2), 0 ) != Xlen )
12675  {
12676  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12677  }
12678  if ( _dim( args(2), 1 ) != Ylen )
12679  {
12680  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12681  }
12682  temp3 = args(2).matrix_value();
12683  arg3 = &temp3( 0, 0 );
12684  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12685  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12686  }
12687  ecode6 = SWIG_AsVal_int(args(3), &val6);
12688  if (!SWIG_IsOK(ecode6)) {
12689  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
12690  }
12691  arg6 = static_cast< PLINT >(val6);
12692  {
12693  if ( _n_dims( args(4) ) > 1 )
12694  {
12695  error( "argument must be a scalar or vector" ); SWIG_fail;
12696  }
12697  temp7 = args(4).matrix_value();
12698  arg7 = &temp7( 0, 0 );
12699  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12700  }
12701  my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12702  _outv = octave_value();
12703  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12704  {
12705 
12706  }
12707  {
12708 
12709  }
12710  {
12711 
12712  }
12713  {
12714 
12715  }
12716  return _out;
12717 fail:
12718  {
12719 
12720  }
12721  {
12722 
12723  }
12724  {
12725 
12726  }
12727  {
12728 
12729  }
12730  return octave_value_list();
12731 }
12732 
12733 
12735  PLFLT *arg1 = (PLFLT *) 0 ;
12736  PLFLT *arg2 = (PLFLT *) 0 ;
12737  PLFLT *arg3 = (PLFLT *) 0 ;
12738  PLINT arg4 ;
12739  PLINT arg5 ;
12740  PLINT arg6 ;
12741  PLFLT *arg7 = (PLFLT *) 0 ;
12742  PLINT arg8 ;
12743  PLINT arg9 ;
12744  PLINT arg10 ;
12745  PLINT *arg11 = (PLINT *) 0 ;
12746  PLINT *arg12 = (PLINT *) 0 ;
12747  Matrix temp1 ;
12748  Matrix temp2 ;
12749  Matrix temp3 ;
12750  int val6 ;
12751  int ecode6 = 0 ;
12752  Matrix temp7 ;
12753  int val9 ;
12754  int ecode9 = 0 ;
12755  Matrix temp10 ;
12756  Matrix temp12 ;
12757  octave_value_list _out;
12758  octave_value_list *_outp=&_out;
12759  octave_value _outv;
12760 
12761  if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
12762  SWIG_fail;
12763  }
12764  {
12765  if ( _n_dims( args(0) ) > 1 )
12766  {
12767  error( "argument must be a scalar or vector" ); SWIG_fail;
12768  }
12769  temp1 = args(0).matrix_value();
12770  arg1 = &temp1( 0, 0 );
12771  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12772  }
12773  {
12774  if ( _n_dims( args(1) ) > 1 )
12775  {
12776  error( "argument must be a scalar or vector" ); SWIG_fail;
12777  }
12778  temp2 = args(1).matrix_value();
12779  arg2 = &temp2( 0, 0 );
12780  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12781  }
12782  {
12783  if ( _n_dims( args(2) ) > 2 )
12784  {
12785  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12786  }
12787  if ( _dim( args(2), 0 ) != Xlen )
12788  {
12789  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12790  }
12791  if ( _dim( args(2), 1 ) != Ylen )
12792  {
12793  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12794  }
12795  temp3 = args(2).matrix_value();
12796  arg3 = &temp3( 0, 0 );
12797  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12798  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12799  }
12800  ecode6 = SWIG_AsVal_int(args(3), &val6);
12801  if (!SWIG_IsOK(ecode6)) {
12802  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
12803  }
12804  arg6 = static_cast< PLINT >(val6);
12805  {
12806  if ( _n_dims( args(4) ) > 1 )
12807  {
12808  error( "argument must be a scalar or vector" ); SWIG_fail;
12809  }
12810  temp7 = args(4).matrix_value();
12811  arg7 = &temp7( 0, 0 );
12812  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12813  }
12814  ecode9 = SWIG_AsVal_int(args(5), &val9);
12815  if (!SWIG_IsOK(ecode9)) {
12816  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
12817  }
12818  arg9 = static_cast< PLINT >(val9);
12819  {
12820  if ( _n_dims( args(6) ) > 1 )
12821  {
12822  error( "argument must be a scalar or vector" ); SWIG_fail;
12823  }
12824  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12825  arg11 = new PLINT[Alen];
12826  temp10 = args(6).matrix_value();
12827  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12828  }
12829  {
12830  if ( _n_dims( args(7) ) > 1 )
12831  {
12832  error( "argument must be a scalar or vector" ); SWIG_fail;
12833  }
12834  if ( _dim( args(7), 0 ) != Alen )
12835  {
12836  error( "argument vectors must be same length" ); SWIG_fail;
12837  }
12838  temp12 = args(7).matrix_value();
12839  arg12 = new PLINT[Alen];
12840  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12841  }
12842  my_plsurf3dl((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8,arg9,arg10,(int const *)arg11,(int const *)arg12);
12843  _outv = octave_value();
12844  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12845  {
12846 
12847  }
12848  {
12849 
12850  }
12851  {
12852 
12853  }
12854  {
12855 
12856  }
12857  {
12858  delete [] arg11;
12859  }
12860  {
12861  delete [] arg12;
12862  }
12863  return _out;
12864 fail:
12865  {
12866 
12867  }
12868  {
12869 
12870  }
12871  {
12872 
12873  }
12874  {
12875 
12876  }
12877  {
12878  delete [] arg11;
12879  }
12880  {
12881  delete [] arg12;
12882  }
12883  return octave_value_list();
12884 }
12885 
12886 
12888  PLFLT *arg1 = (PLFLT *) 0 ;
12889  PLINT arg2 ;
12890  PLINT arg3 ;
12891  PLFLT *arg4 = (PLFLT *) 0 ;
12892  PLFLT arg5 ;
12893  PLFLT arg6 ;
12894  PLFLT arg7 ;
12895  PLFLT arg8 ;
12896  PLFLT arg9 ;
12897  PLFLT arg10 ;
12898  PLINT arg11 ;
12899  PLFLT arg12 ;
12900  PLINT arg13 ;
12901  PLINT arg14 ;
12902  PLINT arg15 ;
12903  PLINT arg16 ;
12904  PLINT arg17 ;
12905  PLBOOL arg18 ;
12906  PLFLT *arg19 = (PLFLT *) 0 ;
12907  Matrix temp1 ;
12908  Matrix temp4 ;
12909  double val5 ;
12910  int ecode5 = 0 ;
12911  double val6 ;
12912  int ecode6 = 0 ;
12913  double val7 ;
12914  int ecode7 = 0 ;
12915  double val8 ;
12916  int ecode8 = 0 ;
12917  double val9 ;
12918  int ecode9 = 0 ;
12919  double val10 ;
12920  int ecode10 = 0 ;
12921  int val11 ;
12922  int ecode11 = 0 ;
12923  double val12 ;
12924  int ecode12 = 0 ;
12925  int val13 ;
12926  int ecode13 = 0 ;
12927  int val14 ;
12928  int ecode14 = 0 ;
12929  int val15 ;
12930  int ecode15 = 0 ;
12931  int val16 ;
12932  int ecode16 = 0 ;
12933  int val17 ;
12934  int ecode17 = 0 ;
12935  int val18 ;
12936  int ecode18 = 0 ;
12937  Matrix temp19 ;
12938  octave_value_list _out;
12939  octave_value_list *_outp=&_out;
12940  octave_value _outv;
12941 
12942  if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
12943  SWIG_fail;
12944  }
12945  {
12946  if ( _n_dims( args(0) ) > 2 )
12947  {
12948  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12949  }
12950  temp1 = args(0).matrix_value();
12951  arg1 = &temp1( 0, 0 );
12952  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12953  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12954  }
12955  {
12956  if ( _n_dims( args(1) ) > 1 )
12957  {
12958  error( "argument must be a scalar or vector" ); SWIG_fail;
12959  }
12960  Alen = (PLINT) ( _dim( args(1), 0 ) );
12961  temp4 = args(1).matrix_value();
12962  arg4 = &temp4( 0, 0 );
12963  }
12964  ecode5 = SWIG_AsVal_double(args(2), &val5);
12965  if (!SWIG_IsOK(ecode5)) {
12966  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12967  }
12968  arg5 = static_cast< PLFLT >(val5);
12969  ecode6 = SWIG_AsVal_double(args(3), &val6);
12970  if (!SWIG_IsOK(ecode6)) {
12971  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12972  }
12973  arg6 = static_cast< PLFLT >(val6);
12974  ecode7 = SWIG_AsVal_double(args(4), &val7);
12975  if (!SWIG_IsOK(ecode7)) {
12976  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12977  }
12978  arg7 = static_cast< PLFLT >(val7);
12979  ecode8 = SWIG_AsVal_double(args(5), &val8);
12980  if (!SWIG_IsOK(ecode8)) {
12981  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12982  }
12983  arg8 = static_cast< PLFLT >(val8);
12984  ecode9 = SWIG_AsVal_double(args(6), &val9);
12985  if (!SWIG_IsOK(ecode9)) {
12986  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12987  }
12988  arg9 = static_cast< PLFLT >(val9);
12989  ecode10 = SWIG_AsVal_double(args(7), &val10);
12990  if (!SWIG_IsOK(ecode10)) {
12991  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12992  }
12993  arg10 = static_cast< PLFLT >(val10);
12994  ecode11 = SWIG_AsVal_int(args(8), &val11);
12995  if (!SWIG_IsOK(ecode11)) {
12996  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
12997  }
12998  arg11 = static_cast< PLINT >(val11);
12999  ecode12 = SWIG_AsVal_double(args(9), &val12);
13000  if (!SWIG_IsOK(ecode12)) {
13001  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13002  }
13003  arg12 = static_cast< PLFLT >(val12);
13004  ecode13 = SWIG_AsVal_int(args(10), &val13);
13005  if (!SWIG_IsOK(ecode13)) {
13006  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13007  }
13008  arg13 = static_cast< PLINT >(val13);
13009  ecode14 = SWIG_AsVal_int(args(11), &val14);
13010  if (!SWIG_IsOK(ecode14)) {
13011  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13012  }
13013  arg14 = static_cast< PLINT >(val14);
13014  ecode15 = SWIG_AsVal_int(args(12), &val15);
13015  if (!SWIG_IsOK(ecode15)) {
13016  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13017  }
13018  arg15 = static_cast< PLINT >(val15);
13019  ecode16 = SWIG_AsVal_int(args(13), &val16);
13020  if (!SWIG_IsOK(ecode16)) {
13021  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13022  }
13023  arg16 = static_cast< PLINT >(val16);
13024  ecode17 = SWIG_AsVal_int(args(14), &val17);
13025  if (!SWIG_IsOK(ecode17)) {
13026  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13027  }
13028  arg17 = static_cast< PLINT >(val17);
13029  ecode18 = SWIG_AsVal_int(args(15), &val18);
13030  if (!SWIG_IsOK(ecode18)) {
13031  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13032  }
13033  arg18 = static_cast< PLBOOL >(val18);
13034  {
13035  if ( _n_dims( args(16) ) > 1 )
13036  {
13037  error( "argument must be a scalar or vector" ); SWIG_fail;
13038  }
13039  if ( _dim( args(16), 0 ) != 6 )
13040  {
13041  error( "argument vectors must have length of 6" ); SWIG_fail;
13042  }
13043  temp19 = args(16).matrix_value();
13044  arg19 = &temp19( 0, 0 );
13045  }
13046  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);
13047  _outv = octave_value();
13048  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13049  {
13050 
13051  }
13052  {
13053 
13054  }
13055  {
13056 
13057  }
13058  return _out;
13059 fail:
13060  {
13061 
13062  }
13063  {
13064 
13065  }
13066  {
13067 
13068  }
13069  return octave_value_list();
13070 }
13071 
13072 
13073 SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13074  PLFLT *arg1 = (PLFLT *) 0 ;
13075  PLINT arg2 ;
13076  PLINT arg3 ;
13077  char *arg4 = (char *) 0 ;
13078  PLFLT arg5 ;
13079  PLFLT arg6 ;
13080  PLFLT arg7 ;
13081  PLFLT arg8 ;
13082  PLFLT arg9 ;
13083  PLFLT arg10 ;
13084  PLINT arg11 ;
13085  PLFLT arg12 ;
13086  PLINT arg13 ;
13087  PLINT arg14 ;
13088  PLINT arg15 ;
13089  PLINT arg16 ;
13090  PLINT arg17 ;
13091  PLBOOL arg18 ;
13092  PLFLT *arg19 = (PLFLT *) 0 ;
13093  PLFLT *arg20 = (PLFLT *) 0 ;
13094  Matrix temp1 ;
13095  int res4 ;
13096  char *buf4 = 0 ;
13097  int alloc4 = 0 ;
13098  double val5 ;
13099  int ecode5 = 0 ;
13100  double val6 ;
13101  int ecode6 = 0 ;
13102  double val7 ;
13103  int ecode7 = 0 ;
13104  double val8 ;
13105  int ecode8 = 0 ;
13106  double val9 ;
13107  int ecode9 = 0 ;
13108  double val10 ;
13109  int ecode10 = 0 ;
13110  int val11 ;
13111  int ecode11 = 0 ;
13112  double val12 ;
13113  int ecode12 = 0 ;
13114  int val13 ;
13115  int ecode13 = 0 ;
13116  int val14 ;
13117  int ecode14 = 0 ;
13118  int val15 ;
13119  int ecode15 = 0 ;
13120  int val16 ;
13121  int ecode16 = 0 ;
13122  int val17 ;
13123  int ecode17 = 0 ;
13124  int val18 ;
13125  int ecode18 = 0 ;
13126  Matrix temp19 ;
13127  Matrix temp20 ;
13128  octave_value_list _out;
13129  octave_value_list *_outp=&_out;
13130  octave_value _outv;
13131 
13132  if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13133  SWIG_fail;
13134  }
13135  {
13136  if ( _n_dims( args(0) ) > 2 )
13137  {
13138  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13139  }
13140  temp1 = args(0).matrix_value();
13141  arg1 = &temp1( 0, 0 );
13142  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13143  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13144  }
13145  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13146  if (!SWIG_IsOK(res4)) {
13147  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13148  }
13149  arg4 = reinterpret_cast< char * >(buf4);
13150  ecode5 = SWIG_AsVal_double(args(2), &val5);
13151  if (!SWIG_IsOK(ecode5)) {
13152  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13153  }
13154  arg5 = static_cast< PLFLT >(val5);
13155  ecode6 = SWIG_AsVal_double(args(3), &val6);
13156  if (!SWIG_IsOK(ecode6)) {
13157  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13158  }
13159  arg6 = static_cast< PLFLT >(val6);
13160  ecode7 = SWIG_AsVal_double(args(4), &val7);
13161  if (!SWIG_IsOK(ecode7)) {
13162  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13163  }
13164  arg7 = static_cast< PLFLT >(val7);
13165  ecode8 = SWIG_AsVal_double(args(5), &val8);
13166  if (!SWIG_IsOK(ecode8)) {
13167  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13168  }
13169  arg8 = static_cast< PLFLT >(val8);
13170  ecode9 = SWIG_AsVal_double(args(6), &val9);
13171  if (!SWIG_IsOK(ecode9)) {
13172  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13173  }
13174  arg9 = static_cast< PLFLT >(val9);
13175  ecode10 = SWIG_AsVal_double(args(7), &val10);
13176  if (!SWIG_IsOK(ecode10)) {
13177  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13178  }
13179  arg10 = static_cast< PLFLT >(val10);
13180  ecode11 = SWIG_AsVal_int(args(8), &val11);
13181  if (!SWIG_IsOK(ecode11)) {
13182  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13183  }
13184  arg11 = static_cast< PLINT >(val11);
13185  ecode12 = SWIG_AsVal_double(args(9), &val12);
13186  if (!SWIG_IsOK(ecode12)) {
13187  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13188  }
13189  arg12 = static_cast< PLFLT >(val12);
13190  ecode13 = SWIG_AsVal_int(args(10), &val13);
13191  if (!SWIG_IsOK(ecode13)) {
13192  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13193  }
13194  arg13 = static_cast< PLINT >(val13);
13195  ecode14 = SWIG_AsVal_int(args(11), &val14);
13196  if (!SWIG_IsOK(ecode14)) {
13197  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13198  }
13199  arg14 = static_cast< PLINT >(val14);
13200  ecode15 = SWIG_AsVal_int(args(12), &val15);
13201  if (!SWIG_IsOK(ecode15)) {
13202  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13203  }
13204  arg15 = static_cast< PLINT >(val15);
13205  ecode16 = SWIG_AsVal_int(args(13), &val16);
13206  if (!SWIG_IsOK(ecode16)) {
13207  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13208  }
13209  arg16 = static_cast< PLINT >(val16);
13210  ecode17 = SWIG_AsVal_int(args(14), &val17);
13211  if (!SWIG_IsOK(ecode17)) {
13212  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13213  }
13214  arg17 = static_cast< PLINT >(val17);
13215  ecode18 = SWIG_AsVal_int(args(15), &val18);
13216  if (!SWIG_IsOK(ecode18)) {
13217  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13218  }
13219  arg18 = static_cast< PLBOOL >(val18);
13220  {
13221  if ( _n_dims( args(16) ) > 1 )
13222  {
13223  error( "argument must be a scalar or vector" ); SWIG_fail;
13224  }
13225  if ( _dim( args(16), 0 ) != Xlen )
13226  {
13227  error( "argument vectors must be same length" ); SWIG_fail;
13228  }
13229  temp19 = args(16).matrix_value();
13230  arg19 = &temp19( 0, 0 );
13231  }
13232  {
13233  if ( _n_dims( args(17) ) > 1 )
13234  {
13235  error( "argument must be a scalar or vector" ); SWIG_fail;
13236  }
13237  if ( _dim( args(17), 0 ) != Ylen )
13238  {
13239  error( "argument vectors must be same length" ); SWIG_fail;
13240  }
13241  temp20 = args(17).matrix_value();
13242  arg20 = &temp20( 0, 0 );
13243  }
13244  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);
13245  _outv = octave_value();
13246  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13247  {
13248 
13249  }
13250  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13251  {
13252 
13253  }
13254  {
13255 
13256  }
13257  return _out;
13258 fail:
13259  {
13260 
13261  }
13262  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13263  {
13264 
13265  }
13266  {
13267 
13268  }
13269  return octave_value_list();
13270 }
13271 
13272 
13273 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13274  PLFLT *arg1 = (PLFLT *) 0 ;
13275  PLINT arg2 ;
13276  PLINT arg3 ;
13277  char *arg4 = (char *) 0 ;
13278  PLFLT arg5 ;
13279  PLFLT arg6 ;
13280  PLFLT arg7 ;
13281  PLFLT arg8 ;
13282  PLFLT arg9 ;
13283  PLFLT arg10 ;
13284  PLINT arg11 ;
13285  PLFLT arg12 ;
13286  PLINT arg13 ;
13287  PLINT arg14 ;
13288  PLINT arg15 ;
13289  PLINT arg16 ;
13290  PLINT arg17 ;
13291  PLBOOL arg18 ;
13292  PLFLT *arg19 = (PLFLT *) 0 ;
13293  PLFLT *arg20 = (PLFLT *) 0 ;
13294  Matrix temp1 ;
13295  int res4 ;
13296  char *buf4 = 0 ;
13297  int alloc4 = 0 ;
13298  double val5 ;
13299  int ecode5 = 0 ;
13300  double val6 ;
13301  int ecode6 = 0 ;
13302  double val7 ;
13303  int ecode7 = 0 ;
13304  double val8 ;
13305  int ecode8 = 0 ;
13306  double val9 ;
13307  int ecode9 = 0 ;
13308  double val10 ;
13309  int ecode10 = 0 ;
13310  int val11 ;
13311  int ecode11 = 0 ;
13312  double val12 ;
13313  int ecode12 = 0 ;
13314  int val13 ;
13315  int ecode13 = 0 ;
13316  int val14 ;
13317  int ecode14 = 0 ;
13318  int val15 ;
13319  int ecode15 = 0 ;
13320  int val16 ;
13321  int ecode16 = 0 ;
13322  int val17 ;
13323  int ecode17 = 0 ;
13324  int val18 ;
13325  int ecode18 = 0 ;
13326  Matrix temp19 ;
13327  Matrix temp20 ;
13328  octave_value_list _out;
13329  octave_value_list *_outp=&_out;
13330  octave_value _outv;
13331 
13332  if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13333  SWIG_fail;
13334  }
13335  {
13336  if ( _n_dims( args(0) ) > 2 )
13337  {
13338  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13339  }
13340  temp1 = args(0).matrix_value();
13341  arg1 = &temp1( 0, 0 );
13342  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13343  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13344  }
13345  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13346  if (!SWIG_IsOK(res4)) {
13347  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13348  }
13349  arg4 = reinterpret_cast< char * >(buf4);
13350  ecode5 = SWIG_AsVal_double(args(2), &val5);
13351  if (!SWIG_IsOK(ecode5)) {
13352  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13353  }
13354  arg5 = static_cast< PLFLT >(val5);
13355  ecode6 = SWIG_AsVal_double(args(3), &val6);
13356  if (!SWIG_IsOK(ecode6)) {
13357  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13358  }
13359  arg6 = static_cast< PLFLT >(val6);
13360  ecode7 = SWIG_AsVal_double(args(4), &val7);
13361  if (!SWIG_IsOK(ecode7)) {
13362  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13363  }
13364  arg7 = static_cast< PLFLT >(val7);
13365  ecode8 = SWIG_AsVal_double(args(5), &val8);
13366  if (!SWIG_IsOK(ecode8)) {
13367  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13368  }
13369  arg8 = static_cast< PLFLT >(val8);
13370  ecode9 = SWIG_AsVal_double(args(6), &val9);
13371  if (!SWIG_IsOK(ecode9)) {
13372  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13373  }
13374  arg9 = static_cast< PLFLT >(val9);
13375  ecode10 = SWIG_AsVal_double(args(7), &val10);
13376  if (!SWIG_IsOK(ecode10)) {
13377  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13378  }
13379  arg10 = static_cast< PLFLT >(val10);
13380  ecode11 = SWIG_AsVal_int(args(8), &val11);
13381  if (!SWIG_IsOK(ecode11)) {
13382  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13383  }
13384  arg11 = static_cast< PLINT >(val11);
13385  ecode12 = SWIG_AsVal_double(args(9), &val12);
13386  if (!SWIG_IsOK(ecode12)) {
13387  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13388  }
13389  arg12 = static_cast< PLFLT >(val12);
13390  ecode13 = SWIG_AsVal_int(args(10), &val13);
13391  if (!SWIG_IsOK(ecode13)) {
13392  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13393  }
13394  arg13 = static_cast< PLINT >(val13);
13395  ecode14 = SWIG_AsVal_int(args(11), &val14);
13396  if (!SWIG_IsOK(ecode14)) {
13397  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13398  }
13399  arg14 = static_cast< PLINT >(val14);
13400  ecode15 = SWIG_AsVal_int(args(12), &val15);
13401  if (!SWIG_IsOK(ecode15)) {
13402  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13403  }
13404  arg15 = static_cast< PLINT >(val15);
13405  ecode16 = SWIG_AsVal_int(args(13), &val16);
13406  if (!SWIG_IsOK(ecode16)) {
13407  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13408  }
13409  arg16 = static_cast< PLINT >(val16);
13410  ecode17 = SWIG_AsVal_int(args(14), &val17);
13411  if (!SWIG_IsOK(ecode17)) {
13412  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13413  }
13414  arg17 = static_cast< PLINT >(val17);
13415  ecode18 = SWIG_AsVal_int(args(15), &val18);
13416  if (!SWIG_IsOK(ecode18)) {
13417  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13418  }
13419  arg18 = static_cast< PLBOOL >(val18);
13420  {
13421  if ( _n_dims( args(16) ) > 2 )
13422  {
13423  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13424  }
13425  temp19 = args(16).matrix_value();
13426  arg19 = &temp19( 0, 0 );
13427  Xlen = (PLINT) ( _dim( args(16), 0 ) );
13428  Ylen = (PLINT) ( _dim( args(16), 1 ) );
13429  }
13430  {
13431  if ( _n_dims( args(17) ) > 2 )
13432  {
13433  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13434  }
13435  temp20 = args(17).matrix_value();
13436  arg20 = &temp20( 0, 0 );
13437  Xlen = (PLINT) ( _dim( args(17), 0 ) );
13438  Ylen = (PLINT) ( _dim( args(17), 1 ) );
13439  }
13440  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);
13441  _outv = octave_value();
13442  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13443  {
13444 
13445  }
13446  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13447  {
13448 
13449  }
13450  {
13451 
13452  }
13453  return _out;
13454 fail:
13455  {
13456 
13457  }
13458  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13459  {
13460 
13461  }
13462  {
13463 
13464  }
13465  return octave_value_list();
13466 }
13467 
13468 
13470  PLFLT *arg1 = (PLFLT *) 0 ;
13471  PLINT arg2 ;
13472  PLINT arg3 ;
13473  PLFLT arg4 ;
13474  PLFLT arg5 ;
13475  PLFLT arg6 ;
13476  PLFLT arg7 ;
13477  PLFLT *arg8 = (PLFLT *) 0 ;
13478  PLINT arg9 ;
13479  PLINT arg10 ;
13480  PLINT arg11 ;
13481  PLINT arg12 ;
13482  PLBOOL arg13 ;
13483  Matrix temp1 ;
13484  double val4 ;
13485  int ecode4 = 0 ;
13486  double val5 ;
13487  int ecode5 = 0 ;
13488  double val6 ;
13489  int ecode6 = 0 ;
13490  double val7 ;
13491  int ecode7 = 0 ;
13492  Matrix temp8 ;
13493  int val10 ;
13494  int ecode10 = 0 ;
13495  int val11 ;
13496  int ecode11 = 0 ;
13497  int val12 ;
13498  int ecode12 = 0 ;
13499  int val13 ;
13500  int ecode13 = 0 ;
13501  octave_value_list _out;
13502  octave_value_list *_outp=&_out;
13503  octave_value _outv;
13504 
13505  if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
13506  SWIG_fail;
13507  }
13508  {
13509  if ( _n_dims( args(0) ) > 2 )
13510  {
13511  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13512  }
13513  temp1 = args(0).matrix_value();
13514  arg1 = &temp1( 0, 0 );
13515  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13516  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13517  }
13518  ecode4 = SWIG_AsVal_double(args(1), &val4);
13519  if (!SWIG_IsOK(ecode4)) {
13520  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
13521  }
13522  arg4 = static_cast< PLFLT >(val4);
13523  ecode5 = SWIG_AsVal_double(args(2), &val5);
13524  if (!SWIG_IsOK(ecode5)) {
13525  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
13526  }
13527  arg5 = static_cast< PLFLT >(val5);
13528  ecode6 = SWIG_AsVal_double(args(3), &val6);
13529  if (!SWIG_IsOK(ecode6)) {
13530  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
13531  }
13532  arg6 = static_cast< PLFLT >(val6);
13533  ecode7 = SWIG_AsVal_double(args(4), &val7);
13534  if (!SWIG_IsOK(ecode7)) {
13535  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
13536  }
13537  arg7 = static_cast< PLFLT >(val7);
13538  {
13539  if ( _n_dims( args(5) ) > 1 )
13540  {
13541  error( "argument must be a scalar or vector" ); SWIG_fail;
13542  }
13543  temp8 = args(5).matrix_value();
13544  arg8 = &temp8( 0, 0 );
13545  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13546  }
13547  ecode10 = SWIG_AsVal_int(args(6), &val10);
13548  if (!SWIG_IsOK(ecode10)) {
13549  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
13550  }
13551  arg10 = static_cast< PLINT >(val10);
13552  ecode11 = SWIG_AsVal_int(args(7), &val11);
13553  if (!SWIG_IsOK(ecode11)) {
13554  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
13555  }
13556  arg11 = static_cast< PLINT >(val11);
13557  ecode12 = SWIG_AsVal_int(args(8), &val12);
13558  if (!SWIG_IsOK(ecode12)) {
13559  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
13560  }
13561  arg12 = static_cast< PLINT >(val12);
13562  ecode13 = SWIG_AsVal_int(args(9), &val13);
13563  if (!SWIG_IsOK(ecode13)) {
13564  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
13565  }
13566  arg13 = static_cast< PLBOOL >(val13);
13567  my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
13568  _outv = octave_value();
13569  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13570  {
13571 
13572  }
13573  {
13574 
13575  }
13576  return _out;
13577 fail:
13578  {
13579 
13580  }
13581  {
13582 
13583  }
13584  return octave_value_list();
13585 }
13586 
13587 
13588 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
13589  PLFLT *arg1 = (PLFLT *) 0 ;
13590  PLINT arg2 ;
13591  PLINT arg3 ;
13592  PLFLT arg4 ;
13593  PLFLT arg5 ;
13594  PLFLT arg6 ;
13595  PLFLT arg7 ;
13596  PLFLT *arg8 = (PLFLT *) 0 ;
13597  PLINT arg9 ;
13598  PLINT arg10 ;
13599  PLINT arg11 ;
13600  PLINT arg12 ;
13601  PLBOOL arg13 ;
13602  PLFLT *arg14 = (PLFLT *) 0 ;
13603  Matrix temp1 ;
13604  double val4 ;
13605  int ecode4 = 0 ;
13606  double val5 ;
13607  int ecode5 = 0 ;
13608  double val6 ;
13609  int ecode6 = 0 ;
13610  double val7 ;
13611  int ecode7 = 0 ;
13612  Matrix temp8 ;
13613  int val10 ;
13614  int ecode10 = 0 ;
13615  int val11 ;
13616  int ecode11 = 0 ;
13617  int val12 ;
13618  int ecode12 = 0 ;
13619  int val13 ;
13620  int ecode13 = 0 ;
13621  Matrix temp14 ;
13622  octave_value_list _out;
13623  octave_value_list *_outp=&_out;
13624  octave_value _outv;
13625 
13626  if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
13627  SWIG_fail;
13628  }
13629  {
13630  if ( _n_dims( args(0) ) > 2 )
13631  {
13632  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13633  }
13634  temp1 = args(0).matrix_value();
13635  arg1 = &temp1( 0, 0 );
13636  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13637  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13638  }
13639  ecode4 = SWIG_AsVal_double(args(1), &val4);
13640  if (!SWIG_IsOK(ecode4)) {
13641  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
13642  }
13643  arg4 = static_cast< PLFLT >(val4);
13644  ecode5 = SWIG_AsVal_double(args(2), &val5);
13645  if (!SWIG_IsOK(ecode5)) {
13646  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
13647  }
13648  arg5 = static_cast< PLFLT >(val5);
13649  ecode6 = SWIG_AsVal_double(args(3), &val6);
13650  if (!SWIG_IsOK(ecode6)) {
13651  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
13652  }
13653  arg6 = static_cast< PLFLT >(val6);
13654  ecode7 = SWIG_AsVal_double(args(4), &val7);
13655  if (!SWIG_IsOK(ecode7)) {
13656  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
13657  }
13658  arg7 = static_cast< PLFLT >(val7);
13659  {
13660  if ( _n_dims( args(5) ) > 1 )
13661  {
13662  error( "argument must be a scalar or vector" ); SWIG_fail;
13663  }
13664  temp8 = args(5).matrix_value();
13665  arg8 = &temp8( 0, 0 );
13666  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13667  }
13668  ecode10 = SWIG_AsVal_int(args(6), &val10);
13669  if (!SWIG_IsOK(ecode10)) {
13670  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
13671  }
13672  arg10 = static_cast< PLINT >(val10);
13673  ecode11 = SWIG_AsVal_int(args(7), &val11);
13674  if (!SWIG_IsOK(ecode11)) {
13675  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
13676  }
13677  arg11 = static_cast< PLINT >(val11);
13678  ecode12 = SWIG_AsVal_int(args(8), &val12);
13679  if (!SWIG_IsOK(ecode12)) {
13680  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
13681  }
13682  arg12 = static_cast< PLINT >(val12);
13683  ecode13 = SWIG_AsVal_int(args(9), &val13);
13684  if (!SWIG_IsOK(ecode13)) {
13685  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
13686  }
13687  arg13 = static_cast< PLBOOL >(val13);
13688  {
13689  if ( _n_dims( args(10) ) > 1 )
13690  {
13691  error( "argument must be a scalar or vector" ); SWIG_fail;
13692  }
13693  if ( _dim( args(10), 0 ) != 6 )
13694  {
13695  error( "argument vectors must have length of 6" ); SWIG_fail;
13696  }
13697  temp14 = args(10).matrix_value();
13698  arg14 = &temp14( 0, 0 );
13699  }
13700  my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
13701  _outv = octave_value();
13702  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13703  {
13704 
13705  }
13706  {
13707 
13708  }
13709  {
13710 
13711  }
13712  return _out;
13713 fail:
13714  {
13715 
13716  }
13717  {
13718 
13719  }
13720  {
13721 
13722  }
13723  return octave_value_list();
13724 }
13725 
13726 
13727 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
13728  PLFLT *arg1 = (PLFLT *) 0 ;
13729  PLINT arg2 ;
13730  PLINT arg3 ;
13731  PLFLT arg4 ;
13732  PLFLT arg5 ;
13733  PLFLT arg6 ;
13734  PLFLT arg7 ;
13735  PLFLT *arg8 = (PLFLT *) 0 ;
13736  PLINT arg9 ;
13737  PLINT arg10 ;
13738  PLINT arg11 ;
13739  PLINT arg12 ;
13740  PLBOOL arg13 ;
13741  PLFLT *arg14 = (PLFLT *) 0 ;
13742  PLFLT *arg15 = (PLFLT *) 0 ;
13743  Matrix temp1 ;
13744  double val4 ;
13745  int ecode4 = 0 ;
13746  double val5 ;
13747  int ecode5 = 0 ;
13748  double val6 ;
13749  int ecode6 = 0 ;
13750  double val7 ;
13751  int ecode7 = 0 ;
13752  Matrix temp8 ;
13753  int val10 ;
13754  int ecode10 = 0 ;
13755  int val11 ;
13756  int ecode11 = 0 ;
13757  int val12 ;
13758  int ecode12 = 0 ;
13759  int val13 ;
13760  int ecode13 = 0 ;
13761  Matrix temp14 ;
13762  Matrix temp15 ;
13763  octave_value_list _out;
13764  octave_value_list *_outp=&_out;
13765  octave_value _outv;
13766 
13767  if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
13768  SWIG_fail;
13769  }
13770  {
13771  if ( _n_dims( args(0) ) > 2 )
13772  {
13773  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13774  }
13775  temp1 = args(0).matrix_value();
13776  arg1 = &temp1( 0, 0 );
13777  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13778  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13779  }
13780  ecode4 = SWIG_AsVal_double(args(1), &val4);
13781  if (!SWIG_IsOK(ecode4)) {
13782  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
13783  }
13784  arg4 = static_cast< PLFLT >(val4);
13785  ecode5 = SWIG_AsVal_double(args(2), &val5);
13786  if (!SWIG_IsOK(ecode5)) {
13787  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
13788  }
13789  arg5 = static_cast< PLFLT >(val5);
13790  ecode6 = SWIG_AsVal_double(args(3), &val6);
13791  if (!SWIG_IsOK(ecode6)) {
13792  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
13793  }
13794  arg6 = static_cast< PLFLT >(val6);
13795  ecode7 = SWIG_AsVal_double(args(4), &val7);
13796  if (!SWIG_IsOK(ecode7)) {
13797  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
13798  }
13799  arg7 = static_cast< PLFLT >(val7);
13800  {
13801  if ( _n_dims( args(5) ) > 1 )
13802  {
13803  error( "argument must be a scalar or vector" ); SWIG_fail;
13804  }
13805  temp8 = args(5).matrix_value();
13806  arg8 = &temp8( 0, 0 );
13807  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13808  }
13809  ecode10 = SWIG_AsVal_int(args(6), &val10);
13810  if (!SWIG_IsOK(ecode10)) {
13811  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
13812  }
13813  arg10 = static_cast< PLINT >(val10);
13814  ecode11 = SWIG_AsVal_int(args(7), &val11);
13815  if (!SWIG_IsOK(ecode11)) {
13816  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
13817  }
13818  arg11 = static_cast< PLINT >(val11);
13819  ecode12 = SWIG_AsVal_int(args(8), &val12);
13820  if (!SWIG_IsOK(ecode12)) {
13821  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
13822  }
13823  arg12 = static_cast< PLINT >(val12);
13824  ecode13 = SWIG_AsVal_int(args(9), &val13);
13825  if (!SWIG_IsOK(ecode13)) {
13826  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
13827  }
13828  arg13 = static_cast< PLBOOL >(val13);
13829  {
13830  if ( _n_dims( args(10) ) > 1 )
13831  {
13832  error( "argument must be a scalar or vector" ); SWIG_fail;
13833  }
13834  if ( _dim( args(10), 0 ) != Xlen )
13835  {
13836  error( "argument vectors must be same length" ); SWIG_fail;
13837  }
13838  temp14 = args(10).matrix_value();
13839  arg14 = &temp14( 0, 0 );
13840  }
13841  {
13842  if ( _n_dims( args(11) ) > 1 )
13843  {
13844  error( "argument must be a scalar or vector" ); SWIG_fail;
13845  }
13846  if ( _dim( args(11), 0 ) != Ylen )
13847  {
13848  error( "argument vectors must be same length" ); SWIG_fail;
13849  }
13850  temp15 = args(11).matrix_value();
13851  arg15 = &temp15( 0, 0 );
13852  }
13853  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);
13854  _outv = octave_value();
13855  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13856  {
13857 
13858  }
13859  {
13860 
13861  }
13862  {
13863 
13864  }
13865  {
13866 
13867  }
13868  return _out;
13869 fail:
13870  {
13871 
13872  }
13873  {
13874 
13875  }
13876  {
13877 
13878  }
13879  {
13880 
13881  }
13882  return octave_value_list();
13883 }
13884 
13885 
13886 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
13887  PLFLT *arg1 = (PLFLT *) 0 ;
13888  PLINT arg2 ;
13889  PLINT arg3 ;
13890  PLFLT arg4 ;
13891  PLFLT arg5 ;
13892  PLFLT arg6 ;
13893  PLFLT arg7 ;
13894  PLFLT *arg8 = (PLFLT *) 0 ;
13895  PLINT arg9 ;
13896  PLINT arg10 ;
13897  PLINT arg11 ;
13898  PLINT arg12 ;
13899  PLBOOL arg13 ;
13900  PLFLT *arg14 = (PLFLT *) 0 ;
13901  PLFLT *arg15 = (PLFLT *) 0 ;
13902  Matrix temp1 ;
13903  double val4 ;
13904  int ecode4 = 0 ;
13905  double val5 ;
13906  int ecode5 = 0 ;
13907  double val6 ;
13908  int ecode6 = 0 ;
13909  double val7 ;
13910  int ecode7 = 0 ;
13911  Matrix temp8 ;
13912  int val10 ;
13913  int ecode10 = 0 ;
13914  int val11 ;
13915  int ecode11 = 0 ;
13916  int val12 ;
13917  int ecode12 = 0 ;
13918  int val13 ;
13919  int ecode13 = 0 ;
13920  Matrix temp14 ;
13921  Matrix temp15 ;
13922  octave_value_list _out;
13923  octave_value_list *_outp=&_out;
13924  octave_value _outv;
13925 
13926  if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
13927  SWIG_fail;
13928  }
13929  {
13930  if ( _n_dims( args(0) ) > 2 )
13931  {
13932  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13933  }
13934  temp1 = args(0).matrix_value();
13935  arg1 = &temp1( 0, 0 );
13936  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13937  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13938  }
13939  ecode4 = SWIG_AsVal_double(args(1), &val4);
13940  if (!SWIG_IsOK(ecode4)) {
13941  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
13942  }
13943  arg4 = static_cast< PLFLT >(val4);
13944  ecode5 = SWIG_AsVal_double(args(2), &val5);
13945  if (!SWIG_IsOK(ecode5)) {
13946  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
13947  }
13948  arg5 = static_cast< PLFLT >(val5);
13949  ecode6 = SWIG_AsVal_double(args(3), &val6);
13950  if (!SWIG_IsOK(ecode6)) {
13951  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
13952  }
13953  arg6 = static_cast< PLFLT >(val6);
13954  ecode7 = SWIG_AsVal_double(args(4), &val7);
13955  if (!SWIG_IsOK(ecode7)) {
13956  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
13957  }
13958  arg7 = static_cast< PLFLT >(val7);
13959  {
13960  if ( _n_dims( args(5) ) > 1 )
13961  {
13962  error( "argument must be a scalar or vector" ); SWIG_fail;
13963  }
13964  temp8 = args(5).matrix_value();
13965  arg8 = &temp8( 0, 0 );
13966  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13967  }
13968  ecode10 = SWIG_AsVal_int(args(6), &val10);
13969  if (!SWIG_IsOK(ecode10)) {
13970  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
13971  }
13972  arg10 = static_cast< PLINT >(val10);
13973  ecode11 = SWIG_AsVal_int(args(7), &val11);
13974  if (!SWIG_IsOK(ecode11)) {
13975  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
13976  }
13977  arg11 = static_cast< PLINT >(val11);
13978  ecode12 = SWIG_AsVal_int(args(8), &val12);
13979  if (!SWIG_IsOK(ecode12)) {
13980  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
13981  }
13982  arg12 = static_cast< PLINT >(val12);
13983  ecode13 = SWIG_AsVal_int(args(9), &val13);
13984  if (!SWIG_IsOK(ecode13)) {
13985  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
13986  }
13987  arg13 = static_cast< PLBOOL >(val13);
13988  {
13989  if ( _n_dims( args(10) ) > 2 )
13990  {
13991  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13992  }
13993  temp14 = args(10).matrix_value();
13994  arg14 = &temp14( 0, 0 );
13995  Xlen = (PLINT) ( _dim( args(10), 0 ) );
13996  Ylen = (PLINT) ( _dim( args(10), 1 ) );
13997  }
13998  {
13999  if ( _n_dims( args(11) ) > 2 )
14000  {
14001  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14002  }
14003  temp15 = args(11).matrix_value();
14004  arg15 = &temp15( 0, 0 );
14005  Xlen = (PLINT) ( _dim( args(11), 0 ) );
14006  Ylen = (PLINT) ( _dim( args(11), 1 ) );
14007  }
14008  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);
14009  _outv = octave_value();
14010  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14011  {
14012 
14013  }
14014  {
14015 
14016  }
14017  {
14018 
14019  }
14020  {
14021 
14022  }
14023  return _out;
14024 fail:
14025  {
14026 
14027  }
14028  {
14029 
14030  }
14031  {
14032 
14033  }
14034  {
14035 
14036  }
14037  return octave_value_list();
14038 }
14039 
14040 
14042  PLFLT *arg1 = (PLFLT *) 0 ;
14043  PLFLT *arg2 = (PLFLT *) 0 ;
14044  PLINT arg3 ;
14045  PLINT arg4 ;
14046  PLFLT arg5 ;
14047  PLFLT *arg6 = (PLFLT *) 0 ;
14048  Matrix temp1 ;
14049  Matrix temp2 ;
14050  double val5 ;
14051  int ecode5 = 0 ;
14052  Matrix temp6 ;
14053  octave_value_list _out;
14054  octave_value_list *_outp=&_out;
14055  octave_value _outv;
14056 
14057  if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14058  SWIG_fail;
14059  }
14060  {
14061  if ( _n_dims( args(0) ) > 2 )
14062  {
14063  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14064  }
14065  temp1 = args(0).matrix_value();
14066  arg1 = &temp1( 0, 0 );
14067  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14068  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14069  }
14070  {
14071  if ( _n_dims( args(1) ) > 2 )
14072  {
14073  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14074  }
14075  if ( _dim( args(1), 0 ) != Xlen )
14076  {
14077  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14078  }
14079  if ( _dim( args(1), 1 ) != Ylen )
14080  {
14081  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14082  }
14083  temp2 = args(1).matrix_value();
14084  arg2 = &temp2( 0, 0 );
14085  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14086  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14087  }
14088  ecode5 = SWIG_AsVal_double(args(2), &val5);
14089  if (!SWIG_IsOK(ecode5)) {
14090  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14091  }
14092  arg5 = static_cast< PLFLT >(val5);
14093  {
14094  if ( _n_dims( args(3) ) > 1 )
14095  {
14096  error( "argument must be a scalar or vector" ); SWIG_fail;
14097  }
14098  if ( _dim( args(3), 0 ) != 6 )
14099  {
14100  error( "argument vectors must have length of 6" ); SWIG_fail;
14101  }
14102  temp6 = args(3).matrix_value();
14103  arg6 = &temp6( 0, 0 );
14104  }
14105  my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14106  _outv = octave_value();
14107  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14108  {
14109 
14110  }
14111  {
14112 
14113  }
14114  {
14115 
14116  }
14117  return _out;
14118 fail:
14119  {
14120 
14121  }
14122  {
14123 
14124  }
14125  {
14126 
14127  }
14128  return octave_value_list();
14129 }
14130 
14131 
14132 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14133  PLFLT *arg1 = (PLFLT *) 0 ;
14134  PLFLT *arg2 = (PLFLT *) 0 ;
14135  PLINT arg3 ;
14136  PLINT arg4 ;
14137  PLFLT arg5 ;
14138  PLFLT *arg6 = (PLFLT *) 0 ;
14139  PLFLT *arg7 = (PLFLT *) 0 ;
14140  Matrix temp1 ;
14141  Matrix temp2 ;
14142  double val5 ;
14143  int ecode5 = 0 ;
14144  Matrix temp6 ;
14145  Matrix temp7 ;
14146  octave_value_list _out;
14147  octave_value_list *_outp=&_out;
14148  octave_value _outv;
14149 
14150  if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14151  SWIG_fail;
14152  }
14153  {
14154  if ( _n_dims( args(0) ) > 2 )
14155  {
14156  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14157  }
14158  temp1 = args(0).matrix_value();
14159  arg1 = &temp1( 0, 0 );
14160  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14161  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14162  }
14163  {
14164  if ( _n_dims( args(1) ) > 2 )
14165  {
14166  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14167  }
14168  if ( _dim( args(1), 0 ) != Xlen )
14169  {
14170  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14171  }
14172  if ( _dim( args(1), 1 ) != Ylen )
14173  {
14174  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14175  }
14176  temp2 = args(1).matrix_value();
14177  arg2 = &temp2( 0, 0 );
14178  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14179  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14180  }
14181  ecode5 = SWIG_AsVal_double(args(2), &val5);
14182  if (!SWIG_IsOK(ecode5)) {
14183  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14184  }
14185  arg5 = static_cast< PLFLT >(val5);
14186  {
14187  if ( _n_dims( args(3) ) > 1 )
14188  {
14189  error( "argument must be a scalar or vector" ); SWIG_fail;
14190  }
14191  if ( _dim( args(3), 0 ) != Xlen )
14192  {
14193  error( "argument vectors must be same length" ); SWIG_fail;
14194  }
14195  temp6 = args(3).matrix_value();
14196  arg6 = &temp6( 0, 0 );
14197  }
14198  {
14199  if ( _n_dims( args(4) ) > 1 )
14200  {
14201  error( "argument must be a scalar or vector" ); SWIG_fail;
14202  }
14203  if ( _dim( args(4), 0 ) != Ylen )
14204  {
14205  error( "argument vectors must be same length" ); SWIG_fail;
14206  }
14207  temp7 = args(4).matrix_value();
14208  arg7 = &temp7( 0, 0 );
14209  }
14210  my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14211  _outv = octave_value();
14212  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14213  {
14214 
14215  }
14216  {
14217 
14218  }
14219  {
14220 
14221  }
14222  {
14223 
14224  }
14225  return _out;
14226 fail:
14227  {
14228 
14229  }
14230  {
14231 
14232  }
14233  {
14234 
14235  }
14236  {
14237 
14238  }
14239  return octave_value_list();
14240 }
14241 
14242 
14243 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14244  PLFLT *arg1 = (PLFLT *) 0 ;
14245  PLFLT *arg2 = (PLFLT *) 0 ;
14246  PLINT arg3 ;
14247  PLINT arg4 ;
14248  PLFLT arg5 ;
14249  PLFLT *arg6 = (PLFLT *) 0 ;
14250  PLFLT *arg7 = (PLFLT *) 0 ;
14251  Matrix temp1 ;
14252  Matrix temp2 ;
14253  double val5 ;
14254  int ecode5 = 0 ;
14255  Matrix temp6 ;
14256  Matrix temp7 ;
14257  octave_value_list _out;
14258  octave_value_list *_outp=&_out;
14259  octave_value _outv;
14260 
14261  if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14262  SWIG_fail;
14263  }
14264  {
14265  if ( _n_dims( args(0) ) > 2 )
14266  {
14267  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14268  }
14269  temp1 = args(0).matrix_value();
14270  arg1 = &temp1( 0, 0 );
14271  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14272  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14273  }
14274  {
14275  if ( _n_dims( args(1) ) > 2 )
14276  {
14277  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14278  }
14279  if ( _dim( args(1), 0 ) != Xlen )
14280  {
14281  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14282  }
14283  if ( _dim( args(1), 1 ) != Ylen )
14284  {
14285  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14286  }
14287  temp2 = args(1).matrix_value();
14288  arg2 = &temp2( 0, 0 );
14289  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14290  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14291  }
14292  ecode5 = SWIG_AsVal_double(args(2), &val5);
14293  if (!SWIG_IsOK(ecode5)) {
14294  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14295  }
14296  arg5 = static_cast< PLFLT >(val5);
14297  {
14298  if ( _n_dims( args(3) ) > 2 )
14299  {
14300  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14301  }
14302  temp6 = args(3).matrix_value();
14303  arg6 = &temp6( 0, 0 );
14304  Xlen = (PLINT) ( _dim( args(3), 0 ) );
14305  Ylen = (PLINT) ( _dim( args(3), 1 ) );
14306  }
14307  {
14308  if ( _n_dims( args(4) ) > 2 )
14309  {
14310  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14311  }
14312  temp7 = args(4).matrix_value();
14313  arg7 = &temp7( 0, 0 );
14314  Xlen = (PLINT) ( _dim( args(4), 0 ) );
14315  Ylen = (PLINT) ( _dim( args(4), 1 ) );
14316  }
14317  my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14318  _outv = octave_value();
14319  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14320  {
14321 
14322  }
14323  {
14324 
14325  }
14326  {
14327 
14328  }
14329  {
14330 
14331  }
14332  return _out;
14333 fail:
14334  {
14335 
14336  }
14337  {
14338 
14339  }
14340  {
14341 
14342  }
14343  {
14344 
14345  }
14346  return octave_value_list();
14347 }
14348 
14349 
14350 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
14351  PLFLT *arg1 = (PLFLT *) 0 ;
14352  PLINT arg2 ;
14353  PLINT arg3 ;
14354  PLFLT arg4 ;
14355  PLFLT arg5 ;
14356  PLFLT arg6 ;
14357  PLFLT arg7 ;
14358  PLFLT arg8 ;
14359  PLFLT arg9 ;
14360  PLFLT arg10 ;
14361  PLFLT arg11 ;
14362  PLFLT arg12 ;
14363  PLFLT arg13 ;
14364  Matrix temp1 ;
14365  double val4 ;
14366  int ecode4 = 0 ;
14367  double val5 ;
14368  int ecode5 = 0 ;
14369  double val6 ;
14370  int ecode6 = 0 ;
14371  double val7 ;
14372  int ecode7 = 0 ;
14373  double val8 ;
14374  int ecode8 = 0 ;
14375  double val9 ;
14376  int ecode9 = 0 ;
14377  double val10 ;
14378  int ecode10 = 0 ;
14379  double val11 ;
14380  int ecode11 = 0 ;
14381  double val12 ;
14382  int ecode12 = 0 ;
14383  double val13 ;
14384  int ecode13 = 0 ;
14385  octave_value_list _out;
14386  octave_value_list *_outp=&_out;
14387  octave_value _outv;
14388 
14389  if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
14390  SWIG_fail;
14391  }
14392  {
14393  if ( _n_dims( args(0) ) > 2 )
14394  {
14395  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14396  }
14397  temp1 = args(0).matrix_value();
14398  arg1 = &temp1( 0, 0 );
14399  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14400  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14401  }
14402  ecode4 = SWIG_AsVal_double(args(1), &val4);
14403  if (!SWIG_IsOK(ecode4)) {
14404  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
14405  }
14406  arg4 = static_cast< PLFLT >(val4);
14407  ecode5 = SWIG_AsVal_double(args(2), &val5);
14408  if (!SWIG_IsOK(ecode5)) {
14409  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
14410  }
14411  arg5 = static_cast< PLFLT >(val5);
14412  ecode6 = SWIG_AsVal_double(args(3), &val6);
14413  if (!SWIG_IsOK(ecode6)) {
14414  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
14415  }
14416  arg6 = static_cast< PLFLT >(val6);
14417  ecode7 = SWIG_AsVal_double(args(4), &val7);
14418  if (!SWIG_IsOK(ecode7)) {
14419  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
14420  }
14421  arg7 = static_cast< PLFLT >(val7);
14422  ecode8 = SWIG_AsVal_double(args(5), &val8);
14423  if (!SWIG_IsOK(ecode8)) {
14424  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
14425  }
14426  arg8 = static_cast< PLFLT >(val8);
14427  ecode9 = SWIG_AsVal_double(args(6), &val9);
14428  if (!SWIG_IsOK(ecode9)) {
14429  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
14430  }
14431  arg9 = static_cast< PLFLT >(val9);
14432  ecode10 = SWIG_AsVal_double(args(7), &val10);
14433  if (!SWIG_IsOK(ecode10)) {
14434  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
14435  }
14436  arg10 = static_cast< PLFLT >(val10);
14437  ecode11 = SWIG_AsVal_double(args(8), &val11);
14438  if (!SWIG_IsOK(ecode11)) {
14439  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
14440  }
14441  arg11 = static_cast< PLFLT >(val11);
14442  ecode12 = SWIG_AsVal_double(args(9), &val12);
14443  if (!SWIG_IsOK(ecode12)) {
14444  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
14445  }
14446  arg12 = static_cast< PLFLT >(val12);
14447  ecode13 = SWIG_AsVal_double(args(10), &val13);
14448  if (!SWIG_IsOK(ecode13)) {
14449  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
14450  }
14451  arg13 = static_cast< PLFLT >(val13);
14452  my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14453  _outv = octave_value();
14454  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14455  {
14456 
14457  }
14458  return _out;
14459 fail:
14460  {
14461 
14462  }
14463  return octave_value_list();
14464 }
14465 
14466 
14468  PLFLT *arg1 = (PLFLT *) 0 ;
14469  PLINT arg2 ;
14470  PLINT arg3 ;
14471  PLFLT arg4 ;
14472  PLFLT arg5 ;
14473  PLFLT arg6 ;
14474  PLFLT arg7 ;
14475  PLFLT arg8 ;
14476  PLFLT arg9 ;
14477  PLFLT arg10 ;
14478  PLFLT arg11 ;
14479  Matrix temp1 ;
14480  double val4 ;
14481  int ecode4 = 0 ;
14482  double val5 ;
14483  int ecode5 = 0 ;
14484  double val6 ;
14485  int ecode6 = 0 ;
14486  double val7 ;
14487  int ecode7 = 0 ;
14488  double val8 ;
14489  int ecode8 = 0 ;
14490  double val9 ;
14491  int ecode9 = 0 ;
14492  double val10 ;
14493  int ecode10 = 0 ;
14494  double val11 ;
14495  int ecode11 = 0 ;
14496  octave_value_list _out;
14497  octave_value_list *_outp=&_out;
14498  octave_value _outv;
14499 
14500  if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
14501  SWIG_fail;
14502  }
14503  {
14504  if ( _n_dims( args(0) ) > 2 )
14505  {
14506  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14507  }
14508  temp1 = args(0).matrix_value();
14509  arg1 = &temp1( 0, 0 );
14510  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14511  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14512  }
14513  ecode4 = SWIG_AsVal_double(args(1), &val4);
14514  if (!SWIG_IsOK(ecode4)) {
14515  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14516  }
14517  arg4 = static_cast< PLFLT >(val4);
14518  ecode5 = SWIG_AsVal_double(args(2), &val5);
14519  if (!SWIG_IsOK(ecode5)) {
14520  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14521  }
14522  arg5 = static_cast< PLFLT >(val5);
14523  ecode6 = SWIG_AsVal_double(args(3), &val6);
14524  if (!SWIG_IsOK(ecode6)) {
14525  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14526  }
14527  arg6 = static_cast< PLFLT >(val6);
14528  ecode7 = SWIG_AsVal_double(args(4), &val7);
14529  if (!SWIG_IsOK(ecode7)) {
14530  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14531  }
14532  arg7 = static_cast< PLFLT >(val7);
14533  ecode8 = SWIG_AsVal_double(args(5), &val8);
14534  if (!SWIG_IsOK(ecode8)) {
14535  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14536  }
14537  arg8 = static_cast< PLFLT >(val8);
14538  ecode9 = SWIG_AsVal_double(args(6), &val9);
14539  if (!SWIG_IsOK(ecode9)) {
14540  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14541  }
14542  arg9 = static_cast< PLFLT >(val9);
14543  ecode10 = SWIG_AsVal_double(args(7), &val10);
14544  if (!SWIG_IsOK(ecode10)) {
14545  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14546  }
14547  arg10 = static_cast< PLFLT >(val10);
14548  ecode11 = SWIG_AsVal_double(args(8), &val11);
14549  if (!SWIG_IsOK(ecode11)) {
14550  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14551  }
14552  arg11 = static_cast< PLFLT >(val11);
14553  my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14554  _outv = octave_value();
14555  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14556  {
14557 
14558  }
14559  return _out;
14560 fail:
14561  {
14562 
14563  }
14564  return octave_value_list();
14565 }
14566 
14567 
14568 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
14569  PLFLT *arg1 = (PLFLT *) 0 ;
14570  PLINT arg2 ;
14571  PLINT arg3 ;
14572  PLFLT arg4 ;
14573  PLFLT arg5 ;
14574  PLFLT arg6 ;
14575  PLFLT arg7 ;
14576  PLFLT arg8 ;
14577  PLFLT arg9 ;
14578  PLFLT arg10 ;
14579  PLFLT arg11 ;
14580  PLFLT *arg12 = (PLFLT *) 0 ;
14581  Matrix temp1 ;
14582  double val4 ;
14583  int ecode4 = 0 ;
14584  double val5 ;
14585  int ecode5 = 0 ;
14586  double val6 ;
14587  int ecode6 = 0 ;
14588  double val7 ;
14589  int ecode7 = 0 ;
14590  double val8 ;
14591  int ecode8 = 0 ;
14592  double val9 ;
14593  int ecode9 = 0 ;
14594  double val10 ;
14595  int ecode10 = 0 ;
14596  double val11 ;
14597  int ecode11 = 0 ;
14598  Matrix temp12 ;
14599  octave_value_list _out;
14600  octave_value_list *_outp=&_out;
14601  octave_value _outv;
14602 
14603  if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
14604  SWIG_fail;
14605  }
14606  {
14607  if ( _n_dims( args(0) ) > 2 )
14608  {
14609  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14610  }
14611  temp1 = args(0).matrix_value();
14612  arg1 = &temp1( 0, 0 );
14613  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14614  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14615  }
14616  ecode4 = SWIG_AsVal_double(args(1), &val4);
14617  if (!SWIG_IsOK(ecode4)) {
14618  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
14619  }
14620  arg4 = static_cast< PLFLT >(val4);
14621  ecode5 = SWIG_AsVal_double(args(2), &val5);
14622  if (!SWIG_IsOK(ecode5)) {
14623  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
14624  }
14625  arg5 = static_cast< PLFLT >(val5);
14626  ecode6 = SWIG_AsVal_double(args(3), &val6);
14627  if (!SWIG_IsOK(ecode6)) {
14628  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
14629  }
14630  arg6 = static_cast< PLFLT >(val6);
14631  ecode7 = SWIG_AsVal_double(args(4), &val7);
14632  if (!SWIG_IsOK(ecode7)) {
14633  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
14634  }
14635  arg7 = static_cast< PLFLT >(val7);
14636  ecode8 = SWIG_AsVal_double(args(5), &val8);
14637  if (!SWIG_IsOK(ecode8)) {
14638  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
14639  }
14640  arg8 = static_cast< PLFLT >(val8);
14641  ecode9 = SWIG_AsVal_double(args(6), &val9);
14642  if (!SWIG_IsOK(ecode9)) {
14643  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
14644  }
14645  arg9 = static_cast< PLFLT >(val9);
14646  ecode10 = SWIG_AsVal_double(args(7), &val10);
14647  if (!SWIG_IsOK(ecode10)) {
14648  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
14649  }
14650  arg10 = static_cast< PLFLT >(val10);
14651  ecode11 = SWIG_AsVal_double(args(8), &val11);
14652  if (!SWIG_IsOK(ecode11)) {
14653  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
14654  }
14655  arg11 = static_cast< PLFLT >(val11);
14656  {
14657  if ( _n_dims( args(9) ) > 1 )
14658  {
14659  error( "argument must be a scalar or vector" ); SWIG_fail;
14660  }
14661  if ( _dim( args(9), 0 ) != 6 )
14662  {
14663  error( "argument vectors must have length of 6" ); SWIG_fail;
14664  }
14665  temp12 = args(9).matrix_value();
14666  arg12 = &temp12( 0, 0 );
14667  }
14668  my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14669  _outv = octave_value();
14670  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14671  {
14672 
14673  }
14674  {
14675 
14676  }
14677  return _out;
14678 fail:
14679  {
14680 
14681  }
14682  {
14683 
14684  }
14685  return octave_value_list();
14686 }
14687 
14688 
14689 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
14690  PLFLT *arg1 = (PLFLT *) 0 ;
14691  PLINT arg2 ;
14692  PLINT arg3 ;
14693  PLFLT arg4 ;
14694  PLFLT arg5 ;
14695  PLFLT arg6 ;
14696  PLFLT arg7 ;
14697  PLFLT arg8 ;
14698  PLFLT arg9 ;
14699  PLFLT arg10 ;
14700  PLFLT arg11 ;
14701  PLFLT *arg12 = (PLFLT *) 0 ;
14702  PLFLT *arg13 = (PLFLT *) 0 ;
14703  Matrix temp1 ;
14704  double val4 ;
14705  int ecode4 = 0 ;
14706  double val5 ;
14707  int ecode5 = 0 ;
14708  double val6 ;
14709  int ecode6 = 0 ;
14710  double val7 ;
14711  int ecode7 = 0 ;
14712  double val8 ;
14713  int ecode8 = 0 ;
14714  double val9 ;
14715  int ecode9 = 0 ;
14716  double val10 ;
14717  int ecode10 = 0 ;
14718  double val11 ;
14719  int ecode11 = 0 ;
14720  Matrix temp12 ;
14721  Matrix temp13 ;
14722  octave_value_list _out;
14723  octave_value_list *_outp=&_out;
14724  octave_value _outv;
14725 
14726  if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
14727  SWIG_fail;
14728  }
14729  {
14730  if ( _n_dims( args(0) ) > 2 )
14731  {
14732  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14733  }
14734  temp1 = args(0).matrix_value();
14735  arg1 = &temp1( 0, 0 );
14736  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14737  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14738  }
14739  ecode4 = SWIG_AsVal_double(args(1), &val4);
14740  if (!SWIG_IsOK(ecode4)) {
14741  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
14742  }
14743  arg4 = static_cast< PLFLT >(val4);
14744  ecode5 = SWIG_AsVal_double(args(2), &val5);
14745  if (!SWIG_IsOK(ecode5)) {
14746  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
14747  }
14748  arg5 = static_cast< PLFLT >(val5);
14749  ecode6 = SWIG_AsVal_double(args(3), &val6);
14750  if (!SWIG_IsOK(ecode6)) {
14751  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
14752  }
14753  arg6 = static_cast< PLFLT >(val6);
14754  ecode7 = SWIG_AsVal_double(args(4), &val7);
14755  if (!SWIG_IsOK(ecode7)) {
14756  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
14757  }
14758  arg7 = static_cast< PLFLT >(val7);
14759  ecode8 = SWIG_AsVal_double(args(5), &val8);
14760  if (!SWIG_IsOK(ecode8)) {
14761  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
14762  }
14763  arg8 = static_cast< PLFLT >(val8);
14764  ecode9 = SWIG_AsVal_double(args(6), &val9);
14765  if (!SWIG_IsOK(ecode9)) {
14766  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
14767  }
14768  arg9 = static_cast< PLFLT >(val9);
14769  ecode10 = SWIG_AsVal_double(args(7), &val10);
14770  if (!SWIG_IsOK(ecode10)) {
14771  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
14772  }
14773  arg10 = static_cast< PLFLT >(val10);
14774  ecode11 = SWIG_AsVal_double(args(8), &val11);
14775  if (!SWIG_IsOK(ecode11)) {
14776  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
14777  }
14778  arg11 = static_cast< PLFLT >(val11);
14779  {
14780  if ( _n_dims( args(9) ) > 1 )
14781  {
14782  error( "argument must be a scalar or vector" ); SWIG_fail;
14783  }
14784  if ( _dim( args(9), 0 ) != Xlen )
14785  {
14786  error( "argument vectors must be same length" ); SWIG_fail;
14787  }
14788  temp12 = args(9).matrix_value();
14789  arg12 = &temp12( 0, 0 );
14790  }
14791  {
14792  if ( _n_dims( args(10) ) > 1 )
14793  {
14794  error( "argument must be a scalar or vector" ); SWIG_fail;
14795  }
14796  if ( _dim( args(10), 0 ) != Ylen )
14797  {
14798  error( "argument vectors must be same length" ); SWIG_fail;
14799  }
14800  temp13 = args(10).matrix_value();
14801  arg13 = &temp13( 0, 0 );
14802  }
14803  my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
14804  _outv = octave_value();
14805  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14806  {
14807 
14808  }
14809  {
14810 
14811  }
14812  {
14813 
14814  }
14815  return _out;
14816 fail:
14817  {
14818 
14819  }
14820  {
14821 
14822  }
14823  {
14824 
14825  }
14826  return octave_value_list();
14827 }
14828 
14829 
14830 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
14831  PLFLT *arg1 = (PLFLT *) 0 ;
14832  PLINT arg2 ;
14833  PLINT arg3 ;
14834  PLFLT arg4 ;
14835  PLFLT arg5 ;
14836  PLFLT arg6 ;
14837  PLFLT arg7 ;
14838  PLFLT arg8 ;
14839  PLFLT arg9 ;
14840  PLFLT arg10 ;
14841  PLFLT arg11 ;
14842  PLFLT *arg12 = (PLFLT *) 0 ;
14843  PLFLT *arg13 = (PLFLT *) 0 ;
14844  Matrix temp1 ;
14845  double val4 ;
14846  int ecode4 = 0 ;
14847  double val5 ;
14848  int ecode5 = 0 ;
14849  double val6 ;
14850  int ecode6 = 0 ;
14851  double val7 ;
14852  int ecode7 = 0 ;
14853  double val8 ;
14854  int ecode8 = 0 ;
14855  double val9 ;
14856  int ecode9 = 0 ;
14857  double val10 ;
14858  int ecode10 = 0 ;
14859  double val11 ;
14860  int ecode11 = 0 ;
14861  Matrix temp12 ;
14862  Matrix temp13 ;
14863  octave_value_list _out;
14864  octave_value_list *_outp=&_out;
14865  octave_value _outv;
14866 
14867  if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
14868  SWIG_fail;
14869  }
14870  {
14871  if ( _n_dims( args(0) ) > 2 )
14872  {
14873  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14874  }
14875  temp1 = args(0).matrix_value();
14876  arg1 = &temp1( 0, 0 );
14877  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14878  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14879  }
14880  ecode4 = SWIG_AsVal_double(args(1), &val4);
14881  if (!SWIG_IsOK(ecode4)) {
14882  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
14883  }
14884  arg4 = static_cast< PLFLT >(val4);
14885  ecode5 = SWIG_AsVal_double(args(2), &val5);
14886  if (!SWIG_IsOK(ecode5)) {
14887  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
14888  }
14889  arg5 = static_cast< PLFLT >(val5);
14890  ecode6 = SWIG_AsVal_double(args(3), &val6);
14891  if (!SWIG_IsOK(ecode6)) {
14892  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
14893  }
14894  arg6 = static_cast< PLFLT >(val6);
14895  ecode7 = SWIG_AsVal_double(args(4), &val7);
14896  if (!SWIG_IsOK(ecode7)) {
14897  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
14898  }
14899  arg7 = static_cast< PLFLT >(val7);
14900  ecode8 = SWIG_AsVal_double(args(5), &val8);
14901  if (!SWIG_IsOK(ecode8)) {
14902  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
14903  }
14904  arg8 = static_cast< PLFLT >(val8);
14905  ecode9 = SWIG_AsVal_double(args(6), &val9);
14906  if (!SWIG_IsOK(ecode9)) {
14907  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
14908  }
14909  arg9 = static_cast< PLFLT >(val9);
14910  ecode10 = SWIG_AsVal_double(args(7), &val10);
14911  if (!SWIG_IsOK(ecode10)) {
14912  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
14913  }
14914  arg10 = static_cast< PLFLT >(val10);
14915  ecode11 = SWIG_AsVal_double(args(8), &val11);
14916  if (!SWIG_IsOK(ecode11)) {
14917  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
14918  }
14919  arg11 = static_cast< PLFLT >(val11);
14920  {
14921  if ( _n_dims( args(9) ) > 2 )
14922  {
14923  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14924  }
14925  temp12 = args(9).matrix_value();
14926  arg12 = &temp12( 0, 0 );
14927  Xlen = (PLINT) ( _dim( args(9), 0 ) );
14928  Ylen = (PLINT) ( _dim( args(9), 1 ) );
14929  }
14930  {
14931  if ( _n_dims( args(10) ) > 2 )
14932  {
14933  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14934  }
14935  temp13 = args(10).matrix_value();
14936  arg13 = &temp13( 0, 0 );
14937  Xlen = (PLINT) ( _dim( args(10), 0 ) );
14938  Ylen = (PLINT) ( _dim( args(10), 1 ) );
14939  }
14940  my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
14941  _outv = octave_value();
14942  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14943  {
14944 
14945  }
14946  {
14947 
14948  }
14949  {
14950 
14951  }
14952  return _out;
14953 fail:
14954  {
14955 
14956  }
14957  {
14958 
14959  }
14960  {
14961 
14962  }
14963  return octave_value_list();
14964 }
14965 
14966 
14968  PLFLT *arg1 = (PLFLT *) 0 ;
14969  PLFLT *arg2 = (PLFLT *) 0 ;
14970  PLINT arg3 ;
14971  PLINT arg4 ;
14972  PLFLT arg5 ;
14973  PLFLT arg6 ;
14974  PLFLT arg7 ;
14975  PLFLT arg8 ;
14976  PLINT arg9 ;
14977  PLINT arg10 ;
14978  PLINT arg11 ;
14979  PLFLT arg12 ;
14980  PLFLT arg13 ;
14981  PLINT arg14 ;
14982  PLFLT arg15 ;
14983  PLINT arg16 ;
14984  PLINT *arg17 = (PLINT *) 0 ;
14985  char **arg18 = (char **) 0 ;
14986  PLINT arg19 ;
14987  char **arg20 = (char **) 0 ;
14988  PLFLT *arg21 = (PLFLT *) 0 ;
14989  PLINT *arg22 = (PLINT *) 0 ;
14990  PLINT *arg23 = (PLINT *) 0 ;
14991  PLFLT *arg24 = (PLFLT *) 0 ;
14992  PLFLT temp1 ;
14993  int res1 = SWIG_TMPOBJ ;
14994  PLFLT temp2 ;
14995  int res2 = SWIG_TMPOBJ ;
14996  int val3 ;
14997  int ecode3 = 0 ;
14998  int val4 ;
14999  int ecode4 = 0 ;
15000  double val5 ;
15001  int ecode5 = 0 ;
15002  double val6 ;
15003  int ecode6 = 0 ;
15004  double val7 ;
15005  int ecode7 = 0 ;
15006  double val8 ;
15007  int ecode8 = 0 ;
15008  int val9 ;
15009  int ecode9 = 0 ;
15010  int val10 ;
15011  int ecode10 = 0 ;
15012  int val11 ;
15013  int ecode11 = 0 ;
15014  double val12 ;
15015  int ecode12 = 0 ;
15016  double val13 ;
15017  int ecode13 = 0 ;
15018  int val14 ;
15019  int ecode14 = 0 ;
15020  double val15 ;
15021  int ecode15 = 0 ;
15022  Matrix temp16 ;
15023  Matrix temp21 ;
15024  Matrix temp22 ;
15025  Matrix temp23 ;
15026  Matrix temp24 ;
15027  octave_value_list _out;
15028  octave_value_list *_outp=&_out;
15029  octave_value _outv;
15030 
15031  arg1 = &temp1;
15032  arg2 = &temp2;
15033  if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15034  SWIG_fail;
15035  }
15036  ecode3 = SWIG_AsVal_int(args(0), &val3);
15037  if (!SWIG_IsOK(ecode3)) {
15038  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15039  }
15040  arg3 = static_cast< PLINT >(val3);
15041  ecode4 = SWIG_AsVal_int(args(1), &val4);
15042  if (!SWIG_IsOK(ecode4)) {
15043  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15044  }
15045  arg4 = static_cast< PLINT >(val4);
15046  ecode5 = SWIG_AsVal_double(args(2), &val5);
15047  if (!SWIG_IsOK(ecode5)) {
15048  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15049  }
15050  arg5 = static_cast< PLFLT >(val5);
15051  ecode6 = SWIG_AsVal_double(args(3), &val6);
15052  if (!SWIG_IsOK(ecode6)) {
15053  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15054  }
15055  arg6 = static_cast< PLFLT >(val6);
15056  ecode7 = SWIG_AsVal_double(args(4), &val7);
15057  if (!SWIG_IsOK(ecode7)) {
15058  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15059  }
15060  arg7 = static_cast< PLFLT >(val7);
15061  ecode8 = SWIG_AsVal_double(args(5), &val8);
15062  if (!SWIG_IsOK(ecode8)) {
15063  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15064  }
15065  arg8 = static_cast< PLFLT >(val8);
15066  ecode9 = SWIG_AsVal_int(args(6), &val9);
15067  if (!SWIG_IsOK(ecode9)) {
15068  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15069  }
15070  arg9 = static_cast< PLINT >(val9);
15071  ecode10 = SWIG_AsVal_int(args(7), &val10);
15072  if (!SWIG_IsOK(ecode10)) {
15073  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15074  }
15075  arg10 = static_cast< PLINT >(val10);
15076  ecode11 = SWIG_AsVal_int(args(8), &val11);
15077  if (!SWIG_IsOK(ecode11)) {
15078  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15079  }
15080  arg11 = static_cast< PLINT >(val11);
15081  ecode12 = SWIG_AsVal_double(args(9), &val12);
15082  if (!SWIG_IsOK(ecode12)) {
15083  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15084  }
15085  arg12 = static_cast< PLFLT >(val12);
15086  ecode13 = SWIG_AsVal_double(args(10), &val13);
15087  if (!SWIG_IsOK(ecode13)) {
15088  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15089  }
15090  arg13 = static_cast< PLFLT >(val13);
15091  ecode14 = SWIG_AsVal_int(args(11), &val14);
15092  if (!SWIG_IsOK(ecode14)) {
15093  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15094  }
15095  arg14 = static_cast< PLINT >(val14);
15096  ecode15 = SWIG_AsVal_double(args(12), &val15);
15097  if (!SWIG_IsOK(ecode15)) {
15098  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15099  }
15100  arg15 = static_cast< PLFLT >(val15);
15101  {
15102  if ( _n_dims( args(13) ) > 1 )
15103  {
15104  error( "argument must be a scalar or vector" ); SWIG_fail;
15105  }
15106  arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15107  arg17 = new PLINT[Alen];
15108  temp16 = args(13).matrix_value();
15109  _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15110  }
15111  {
15112  charMatrix temp_matrix;
15113  Cell temp_cell;
15114  char *tmp_cstring;
15115  std::string str;
15116  size_t max_length = 0, non_blank_length;
15117  int i, ifcell;
15118  if ( _n_dims( args(14) ) > 2 )
15119  {
15120  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15121  }
15122 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15123  if ( !args(14).isempty() )
15124 #else
15125  if ( !args(14).is_empty() )
15126 #endif
15127  {
15128  if ( _dim( args(14), 0 ) != Alen )
15129  {
15130  error( "first dimension must be same length as previous vector" ); SWIG_fail;
15131  }
15132  arg18 = new char*[Alen];
15133 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15134  ifcell = args(14).iscell();
15135 #else
15136  ifcell = args(14).is_cell();
15137 #endif
15138  if ( ifcell )
15139  {
15140  temp_cell = args(14).cell_value();
15141  }
15142  else
15143  {
15144  temp_matrix = args(14).char_matrix_value();
15145  // Allow one extra space for null termination.
15146  max_length = _dim( args(14), 1 ) + 1;
15147  }
15148 
15149  for ( i = 0; i < Alen; i++ )
15150  {
15151  // Must copy string to "permanent" location because the string
15152  // location corresponding to tmp_cstring gets
15153  // overwritten for each iteration of loop.
15154  if ( ifcell )
15155  {
15156  if ( temp_cell.elem( i ).is_string() )
15157  {
15158  str = temp_cell.elem( i ).string_value();
15159  // leave room for null termination.
15160  max_length = str.size() + 1;
15161  tmp_cstring = (char *) str.c_str();
15162  }
15163  else
15164  {
15165  // Use null string if user attempts to pass a cell array
15166  // with a non-string element (likely an empty element
15167  // since that should be allowed by the PLplot interface
15168  // if that element is going to be unused).
15169  // leave room for null termination.
15170  max_length = 1;
15171  tmp_cstring = (char *) "";
15172  }
15173  }
15174  else
15175  {
15176  str = temp_matrix.row_as_string( i );
15177  tmp_cstring = (char *) str.c_str();
15178  }
15179  arg18[i] = new char[max_length];
15180  strncpy( arg18[i], tmp_cstring, max_length - 1 );
15181  arg18[i][max_length - 1] = '\0';
15182  // All the trailing blank crapola should not be needed for
15183  // string cell arrays.
15184  if ( !ifcell )
15185  {
15186  // remove trailing-blank padding that is used by the
15187  // charMatrix class to insure all strings in a given
15188  // charMatrix instance have the same length.
15189  // This transformation also removes legitimate trailing
15190  // blanks but there is nothing we can do about that
15191  // for the charMatrix class.
15192 
15193  // Look for trailing nulls first (just in case, although that
15194  // shouldn't happen if charMatrix implemented as documented)
15195  // before looking for trailing blanks.
15196  non_blank_length = max_length - 2;
15197  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15198  {
15199  non_blank_length--;
15200  }
15201  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15202  {
15203  non_blank_length--;
15204  }
15205  arg18[i][non_blank_length + 1] = '\0';
15206  }
15207  }
15208  }
15209  else
15210  {
15211  arg18 = NULL;
15212  }
15213  }
15214  {
15215  charMatrix temp_matrix;
15216  Cell temp_cell;
15217  char *tmp_cstring;
15218  std::string str;
15219  size_t max_length = 0, non_blank_length;
15220  int i, ifcell;
15221  if ( _n_dims( args(15) ) > 2 )
15222  {
15223  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15224  }
15225 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15226  if ( !args(15).isempty() )
15227 #else
15228  if ( !args(15).is_empty() )
15229 #endif
15230  {
15231  Alen = _dim( args(15), 0 );
15232  arg19 = Alen;
15233  arg20 = new char*[Alen];
15234 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15235  ifcell = args(15).iscell();
15236 #else
15237  ifcell = args(15).is_cell();
15238 #endif
15239  if ( ifcell )
15240  {
15241  temp_cell = args(15).cell_value();
15242  }
15243  else
15244  {
15245  temp_matrix = args(15).char_matrix_value();
15246  // Allow one extra space for null termination.
15247  max_length = _dim( args(15), 1 ) + 1;
15248  }
15249 
15250  for ( i = 0; i < Alen; i++ )
15251  {
15252  // Must copy string to "permanent" location because the string
15253  // location corresponding to tmp_cstring gets
15254  // overwritten for each iteration of loop.
15255  if ( ifcell )
15256  {
15257  if ( temp_cell.elem( i ).is_string() )
15258  {
15259  str = temp_cell.elem( i ).string_value();
15260  // leave room for null termination.
15261  max_length = str.size() + 1;
15262  tmp_cstring = (char *) str.c_str();
15263  }
15264  else
15265  {
15266  // Use null string if user attempts to pass a cell array
15267  // with a non-string element (likely an empty element
15268  // since that should be allowed by the PLplot interface
15269  // if that element is going to be unused).
15270  // leave room for null termination.
15271  max_length = 1;
15272  tmp_cstring = (char *) "";
15273  }
15274  }
15275  else
15276  {
15277  str = temp_matrix.row_as_string( i );
15278  tmp_cstring = (char *) str.c_str();
15279  }
15280  arg20[i] = new char[max_length];
15281  strncpy( arg20[i], tmp_cstring, max_length - 1 );
15282  arg20[i][max_length - 1] = '\0';
15283  // All the trailing blank crapola should not be needed for
15284  // string cell arrays.
15285  if ( !ifcell )
15286  {
15287  // remove trailing-blank padding that is used by the
15288  // charMatrix class to insure all strings in a given
15289  // charMatrix instance have the same length.
15290  // This transformation also removes legitimate trailing
15291  // blanks but there is nothing we can do about that
15292  // for the charMatrix class.
15293 
15294  // Look for trailing nulls first (just in case, although that
15295  // shouldn't happen if charMatrix implemented as documented)
15296  // before looking for trailing blanks.
15297  non_blank_length = max_length - 2;
15298  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
15299  {
15300  non_blank_length--;
15301  }
15302  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
15303  {
15304  non_blank_length--;
15305  }
15306  arg20[i][non_blank_length + 1] = '\0';
15307  }
15308  }
15309  }
15310  else
15311  {
15312  arg19 = 0;
15313  arg20 = NULL;
15314  }
15315  }
15316  {
15317  if ( _n_dims( args(16) ) > 1 )
15318  {
15319  error( "argument must be a scalar or vector" ); SWIG_fail;
15320  }
15321  if ( _dim( args(16), 0 ) != Alen )
15322  {
15323  error( "argument vectors must be same length" ); SWIG_fail;
15324  }
15325  temp21 = args(16).matrix_value();
15326  arg21 = &temp21( 0, 0 );
15327  }
15328  {
15329  if ( _n_dims( args(17) ) > 1 )
15330  {
15331  error( "argument must be a scalar or vector" ); SWIG_fail;
15332  }
15333  if ( _dim( args(17), 0 ) != Alen )
15334  {
15335  error( "argument vectors must be same length" ); SWIG_fail;
15336  }
15337  temp22 = args(17).matrix_value();
15338  arg22 = new PLINT[Alen];
15339  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
15340  }
15341  {
15342  int i;
15343  if ( _n_dims( args(18) ) > 1 )
15344  {
15345  error( "argument must be a scalar or vector" ); SWIG_fail;
15346  }
15347  if ( _dim( args(18), 0 ) != Alen )
15348  {
15349  error( "argument vectors must be same length" ); SWIG_fail;
15350  }
15351  Xlen = Alen;
15352  temp23 = args(18).matrix_value();
15353  arg23 = new PLINT[Alen];
15354  _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
15355  Ylen = -1;
15356  for ( i = 0; i < Xlen; i++ )
15357  if ( arg23[i] > Ylen )
15358  Ylen = arg23[i];
15359  }
15360  {
15361  if ( _n_dims( args(19) ) > 2 )
15362  {
15363  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15364  }
15365  if ( _dim( args(19), 0 ) != Xlen )
15366  {
15367  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
15368  }
15369  if ( _dim( args(19), 1 ) != Ylen )
15370  {
15371  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
15372  }
15373  temp24 = args(19).matrix_value();
15374  arg24 = &temp24( 0, 0 );
15375  }
15376  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);
15377  _outv = octave_value();
15378  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15379  if (SWIG_IsTmpObj(res1)) {
15380  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15381  } else {
15382  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15383  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15384  }
15385  if (SWIG_IsTmpObj(res2)) {
15386  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15387  } else {
15388  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15389  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15390  }
15391  {
15392  delete [] arg17;
15393  }
15394  {
15395  int i;
15396  if ( arg18 != NULL )
15397  {
15398  for ( i = 0; i < Alen; i++ )
15399  {
15400  delete[] arg18[i];
15401  }
15402  delete[] arg18;
15403  }
15404  }
15405  {
15406  int i;
15407  if ( arg20 != NULL )
15408  {
15409  for ( i = 0; i < Alen; i++ )
15410  {
15411  delete[] arg20[i];
15412  }
15413  delete[] arg20;
15414  }
15415  }
15416  {
15417 
15418  }
15419  {
15420  delete [] arg22;
15421  }
15422  {
15423  delete [] arg23;
15424  }
15425  {
15426 
15427  }
15428  return _out;
15429 fail:
15430  {
15431  delete [] arg17;
15432  }
15433  {
15434  int i;
15435  if ( arg18 != NULL )
15436  {
15437  for ( i = 0; i < Alen; i++ )
15438  {
15439  delete[] arg18[i];
15440  }
15441  delete[] arg18;
15442  }
15443  }
15444  {
15445  int i;
15446  if ( arg20 != NULL )
15447  {
15448  for ( i = 0; i < Alen; i++ )
15449  {
15450  delete[] arg20[i];
15451  }
15452  delete[] arg20;
15453  }
15454  }
15455  {
15456 
15457  }
15458  {
15459  delete [] arg22;
15460  }
15461  {
15462  delete [] arg23;
15463  }
15464  {
15465 
15466  }
15467  return octave_value_list();
15468 }
15469 
15470 
15472  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15473  int arg2 ;
15474  void *argp1 = 0 ;
15475  int res1 = 0 ;
15476  int val2 ;
15477  int ecode2 = 0 ;
15478  octave_value_list _out;
15479  octave_value_list *_outp=&_out;
15480  octave_value _outv;
15481 
15482  if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
15483  SWIG_fail;
15484  }
15485  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15486  if (!SWIG_IsOK(res1)) {
15487  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15488  }
15489  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15490  ecode2 = SWIG_AsVal_int(args(1), &val2);
15491  if (!SWIG_IsOK(ecode2)) {
15492  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
15493  }
15494  arg2 = static_cast< int >(val2);
15495  if (arg1) (arg1)->type = arg2;
15496  _outv = octave_value();
15497  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15498  return _out;
15499 fail:
15500  return octave_value_list();
15501 }
15502 
15503 
15505  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15506  void *argp1 = 0 ;
15507  int res1 = 0 ;
15508  octave_value_list _out;
15509  octave_value_list *_outp=&_out;
15510  octave_value _outv;
15511  int result;
15512 
15513  if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
15514  SWIG_fail;
15515  }
15516  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15517  if (!SWIG_IsOK(res1)) {
15518  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15519  }
15520  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15521  result = (int) ((arg1)->type);
15522  _outv = SWIG_From_int(static_cast< int >(result));
15523  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15524  return _out;
15525 fail:
15526  return octave_value_list();
15527 }
15528 
15529 
15530 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
15531  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15532  unsigned int arg2 ;
15533  void *argp1 = 0 ;
15534  int res1 = 0 ;
15535  unsigned int val2 ;
15536  int ecode2 = 0 ;
15537  octave_value_list _out;
15538  octave_value_list *_outp=&_out;
15539  octave_value _outv;
15540 
15541  if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
15542  SWIG_fail;
15543  }
15544  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15545  if (!SWIG_IsOK(res1)) {
15546  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15547  }
15548  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15549  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15550  if (!SWIG_IsOK(ecode2)) {
15551  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
15552  }
15553  arg2 = static_cast< unsigned int >(val2);
15554  if (arg1) (arg1)->state = arg2;
15555  _outv = octave_value();
15556  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15557  return _out;
15558 fail:
15559  return octave_value_list();
15560 }
15561 
15562 
15563 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
15564  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15565  void *argp1 = 0 ;
15566  int res1 = 0 ;
15567  octave_value_list _out;
15568  octave_value_list *_outp=&_out;
15569  octave_value _outv;
15570  unsigned int result;
15571 
15572  if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
15573  SWIG_fail;
15574  }
15575  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15576  if (!SWIG_IsOK(res1)) {
15577  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15578  }
15579  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15580  result = (unsigned int) ((arg1)->state);
15581  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15582  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15583  return _out;
15584 fail:
15585  return octave_value_list();
15586 }
15587 
15588 
15589 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
15590  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15591  unsigned int arg2 ;
15592  void *argp1 = 0 ;
15593  int res1 = 0 ;
15594  unsigned int val2 ;
15595  int ecode2 = 0 ;
15596  octave_value_list _out;
15597  octave_value_list *_outp=&_out;
15598  octave_value _outv;
15599 
15600  if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
15601  SWIG_fail;
15602  }
15603  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15604  if (!SWIG_IsOK(res1)) {
15605  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15606  }
15607  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15608  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15609  if (!SWIG_IsOK(ecode2)) {
15610  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
15611  }
15612  arg2 = static_cast< unsigned int >(val2);
15613  if (arg1) (arg1)->keysym = arg2;
15614  _outv = octave_value();
15615  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15616  return _out;
15617 fail:
15618  return octave_value_list();
15619 }
15620 
15621 
15622 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
15623  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15624  void *argp1 = 0 ;
15625  int res1 = 0 ;
15626  octave_value_list _out;
15627  octave_value_list *_outp=&_out;
15628  octave_value _outv;
15629  unsigned int result;
15630 
15631  if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
15632  SWIG_fail;
15633  }
15634  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15635  if (!SWIG_IsOK(res1)) {
15636  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15637  }
15638  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15639  result = (unsigned int) ((arg1)->keysym);
15640  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15641  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15642  return _out;
15643 fail:
15644  return octave_value_list();
15645 }
15646 
15647 
15648 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
15649  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15650  unsigned int arg2 ;
15651  void *argp1 = 0 ;
15652  int res1 = 0 ;
15653  unsigned int val2 ;
15654  int ecode2 = 0 ;
15655  octave_value_list _out;
15656  octave_value_list *_outp=&_out;
15657  octave_value _outv;
15658 
15659  if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
15660  SWIG_fail;
15661  }
15662  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15663  if (!SWIG_IsOK(res1)) {
15664  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15665  }
15666  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15667  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15668  if (!SWIG_IsOK(ecode2)) {
15669  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
15670  }
15671  arg2 = static_cast< unsigned int >(val2);
15672  if (arg1) (arg1)->button = arg2;
15673  _outv = octave_value();
15674  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15675  return _out;
15676 fail:
15677  return octave_value_list();
15678 }
15679 
15680 
15681 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
15682  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15683  void *argp1 = 0 ;
15684  int res1 = 0 ;
15685  octave_value_list _out;
15686  octave_value_list *_outp=&_out;
15687  octave_value _outv;
15688  unsigned int result;
15689 
15690  if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
15691  SWIG_fail;
15692  }
15693  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15694  if (!SWIG_IsOK(res1)) {
15695  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15696  }
15697  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15698  result = (unsigned int) ((arg1)->button);
15699  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15700  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15701  return _out;
15702 fail:
15703  return octave_value_list();
15704 }
15705 
15706 
15707 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
15708  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15709  PLINT arg2 ;
15710  void *argp1 = 0 ;
15711  int res1 = 0 ;
15712  int val2 ;
15713  int ecode2 = 0 ;
15714  octave_value_list _out;
15715  octave_value_list *_outp=&_out;
15716  octave_value _outv;
15717 
15718  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
15719  SWIG_fail;
15720  }
15721  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15722  if (!SWIG_IsOK(res1)) {
15723  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15724  }
15725  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15726  ecode2 = SWIG_AsVal_int(args(1), &val2);
15727  if (!SWIG_IsOK(ecode2)) {
15728  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
15729  }
15730  arg2 = static_cast< PLINT >(val2);
15731  if (arg1) (arg1)->subwindow = arg2;
15732  _outv = octave_value();
15733  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15734  return _out;
15735 fail:
15736  return octave_value_list();
15737 }
15738 
15739 
15740 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
15741  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15742  void *argp1 = 0 ;
15743  int res1 = 0 ;
15744  octave_value_list _out;
15745  octave_value_list *_outp=&_out;
15746  octave_value _outv;
15747  PLINT result;
15748 
15749  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
15750  SWIG_fail;
15751  }
15752  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15753  if (!SWIG_IsOK(res1)) {
15754  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15755  }
15756  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15757  result = (PLINT) ((arg1)->subwindow);
15758  _outv = SWIG_From_int(static_cast< int >(result));
15759  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15760  return _out;
15761 fail:
15762  return octave_value_list();
15763 }
15764 
15765 
15766 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
15767  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15768  char *arg2 ;
15769  void *argp1 = 0 ;
15770  int res1 = 0 ;
15771  char temp2[16] ;
15772  int res2 ;
15773  octave_value_list _out;
15774  octave_value_list *_outp=&_out;
15775  octave_value _outv;
15776 
15777  if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
15778  SWIG_fail;
15779  }
15780  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15781  if (!SWIG_IsOK(res1)) {
15782  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15783  }
15784  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15785  res2 = SWIG_AsCharArray(args(1), temp2, 16);
15786  if (!SWIG_IsOK(res2)) {
15787  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
15788  }
15789  arg2 = reinterpret_cast< char * >(temp2);
15790  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
15791  else memset(arg1->string,0,16*sizeof(char));
15792  _outv = octave_value();
15793  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15794  return _out;
15795 fail:
15796  return octave_value_list();
15797 }
15798 
15799 
15800 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
15801  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15802  void *argp1 = 0 ;
15803  int res1 = 0 ;
15804  octave_value_list _out;
15805  octave_value_list *_outp=&_out;
15806  octave_value _outv;
15807  char *result = 0 ;
15808 
15809  if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
15810  SWIG_fail;
15811  }
15812  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15813  if (!SWIG_IsOK(res1)) {
15814  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15815  }
15816  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15817  result = (char *)(char *) ((arg1)->string);
15818  {
15819  size_t size = SWIG_strnlen(result, 16);
15820 
15821 
15822 
15823  _outv = SWIG_FromCharPtrAndSize(result, size);
15824  }
15825  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15826  return _out;
15827 fail:
15828  return octave_value_list();
15829 }
15830 
15831 
15833  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15834  int arg2 ;
15835  void *argp1 = 0 ;
15836  int res1 = 0 ;
15837  int val2 ;
15838  int ecode2 = 0 ;
15839  octave_value_list _out;
15840  octave_value_list *_outp=&_out;
15841  octave_value _outv;
15842 
15843  if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
15844  SWIG_fail;
15845  }
15846  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15847  if (!SWIG_IsOK(res1)) {
15848  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15849  }
15850  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15851  ecode2 = SWIG_AsVal_int(args(1), &val2);
15852  if (!SWIG_IsOK(ecode2)) {
15853  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
15854  }
15855  arg2 = static_cast< int >(val2);
15856  if (arg1) (arg1)->pX = arg2;
15857  _outv = octave_value();
15858  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15859  return _out;
15860 fail:
15861  return octave_value_list();
15862 }
15863 
15864 
15866  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15867  void *argp1 = 0 ;
15868  int res1 = 0 ;
15869  octave_value_list _out;
15870  octave_value_list *_outp=&_out;
15871  octave_value _outv;
15872  int result;
15873 
15874  if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
15875  SWIG_fail;
15876  }
15877  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15878  if (!SWIG_IsOK(res1)) {
15879  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15880  }
15881  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15882  result = (int) ((arg1)->pX);
15883  _outv = SWIG_From_int(static_cast< int >(result));
15884  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15885  return _out;
15886 fail:
15887  return octave_value_list();
15888 }
15889 
15890 
15892  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15893  int arg2 ;
15894  void *argp1 = 0 ;
15895  int res1 = 0 ;
15896  int val2 ;
15897  int ecode2 = 0 ;
15898  octave_value_list _out;
15899  octave_value_list *_outp=&_out;
15900  octave_value _outv;
15901 
15902  if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
15903  SWIG_fail;
15904  }
15905  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15906  if (!SWIG_IsOK(res1)) {
15907  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15908  }
15909  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15910  ecode2 = SWIG_AsVal_int(args(1), &val2);
15911  if (!SWIG_IsOK(ecode2)) {
15912  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
15913  }
15914  arg2 = static_cast< int >(val2);
15915  if (arg1) (arg1)->pY = arg2;
15916  _outv = octave_value();
15917  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15918  return _out;
15919 fail:
15920  return octave_value_list();
15921 }
15922 
15923 
15925  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15926  void *argp1 = 0 ;
15927  int res1 = 0 ;
15928  octave_value_list _out;
15929  octave_value_list *_outp=&_out;
15930  octave_value _outv;
15931  int result;
15932 
15933  if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
15934  SWIG_fail;
15935  }
15936  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15937  if (!SWIG_IsOK(res1)) {
15938  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15939  }
15940  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15941  result = (int) ((arg1)->pY);
15942  _outv = SWIG_From_int(static_cast< int >(result));
15943  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15944  return _out;
15945 fail:
15946  return octave_value_list();
15947 }
15948 
15949 
15951  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15952  PLFLT arg2 ;
15953  void *argp1 = 0 ;
15954  int res1 = 0 ;
15955  double val2 ;
15956  int ecode2 = 0 ;
15957  octave_value_list _out;
15958  octave_value_list *_outp=&_out;
15959  octave_value _outv;
15960 
15961  if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
15962  SWIG_fail;
15963  }
15964  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15965  if (!SWIG_IsOK(res1)) {
15966  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15967  }
15968  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15969  ecode2 = SWIG_AsVal_double(args(1), &val2);
15970  if (!SWIG_IsOK(ecode2)) {
15971  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
15972  }
15973  arg2 = static_cast< PLFLT >(val2);
15974  if (arg1) (arg1)->dX = arg2;
15975  _outv = octave_value();
15976  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15977  return _out;
15978 fail:
15979  return octave_value_list();
15980 }
15981 
15982 
15984  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15985  void *argp1 = 0 ;
15986  int res1 = 0 ;
15987  octave_value_list _out;
15988  octave_value_list *_outp=&_out;
15989  octave_value _outv;
15990  PLFLT result;
15991 
15992  if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
15993  SWIG_fail;
15994  }
15995  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15996  if (!SWIG_IsOK(res1)) {
15997  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15998  }
15999  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16000  result = (PLFLT) ((arg1)->dX);
16001  _outv = SWIG_From_double(static_cast< double >(result));
16002  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16003  return _out;
16004 fail:
16005  return octave_value_list();
16006 }
16007 
16008 
16010  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16011  PLFLT arg2 ;
16012  void *argp1 = 0 ;
16013  int res1 = 0 ;
16014  double val2 ;
16015  int ecode2 = 0 ;
16016  octave_value_list _out;
16017  octave_value_list *_outp=&_out;
16018  octave_value _outv;
16019 
16020  if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16021  SWIG_fail;
16022  }
16023  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16024  if (!SWIG_IsOK(res1)) {
16025  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16026  }
16027  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16028  ecode2 = SWIG_AsVal_double(args(1), &val2);
16029  if (!SWIG_IsOK(ecode2)) {
16030  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16031  }
16032  arg2 = static_cast< PLFLT >(val2);
16033  if (arg1) (arg1)->dY = arg2;
16034  _outv = octave_value();
16035  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16036  return _out;
16037 fail:
16038  return octave_value_list();
16039 }
16040 
16041 
16043  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16044  void *argp1 = 0 ;
16045  int res1 = 0 ;
16046  octave_value_list _out;
16047  octave_value_list *_outp=&_out;
16048  octave_value _outv;
16049  PLFLT result;
16050 
16051  if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16052  SWIG_fail;
16053  }
16054  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16055  if (!SWIG_IsOK(res1)) {
16056  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16057  }
16058  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16059  result = (PLFLT) ((arg1)->dY);
16060  _outv = SWIG_From_double(static_cast< double >(result));
16061  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16062  return _out;
16063 fail:
16064  return octave_value_list();
16065 }
16066 
16067 
16069  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16070  PLFLT arg2 ;
16071  void *argp1 = 0 ;
16072  int res1 = 0 ;
16073  double val2 ;
16074  int ecode2 = 0 ;
16075  octave_value_list _out;
16076  octave_value_list *_outp=&_out;
16077  octave_value _outv;
16078 
16079  if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16080  SWIG_fail;
16081  }
16082  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16083  if (!SWIG_IsOK(res1)) {
16084  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16085  }
16086  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16087  ecode2 = SWIG_AsVal_double(args(1), &val2);
16088  if (!SWIG_IsOK(ecode2)) {
16089  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16090  }
16091  arg2 = static_cast< PLFLT >(val2);
16092  if (arg1) (arg1)->wX = arg2;
16093  _outv = octave_value();
16094  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16095  return _out;
16096 fail:
16097  return octave_value_list();
16098 }
16099 
16100 
16102  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16103  void *argp1 = 0 ;
16104  int res1 = 0 ;
16105  octave_value_list _out;
16106  octave_value_list *_outp=&_out;
16107  octave_value _outv;
16108  PLFLT result;
16109 
16110  if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16111  SWIG_fail;
16112  }
16113  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16114  if (!SWIG_IsOK(res1)) {
16115  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16116  }
16117  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16118  result = (PLFLT) ((arg1)->wX);
16119  _outv = SWIG_From_double(static_cast< double >(result));
16120  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16121  return _out;
16122 fail:
16123  return octave_value_list();
16124 }
16125 
16126 
16128  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16129  PLFLT arg2 ;
16130  void *argp1 = 0 ;
16131  int res1 = 0 ;
16132  double val2 ;
16133  int ecode2 = 0 ;
16134  octave_value_list _out;
16135  octave_value_list *_outp=&_out;
16136  octave_value _outv;
16137 
16138  if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
16139  SWIG_fail;
16140  }
16141  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16142  if (!SWIG_IsOK(res1)) {
16143  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16144  }
16145  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16146  ecode2 = SWIG_AsVal_double(args(1), &val2);
16147  if (!SWIG_IsOK(ecode2)) {
16148  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
16149  }
16150  arg2 = static_cast< PLFLT >(val2);
16151  if (arg1) (arg1)->wY = arg2;
16152  _outv = octave_value();
16153  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16154  return _out;
16155 fail:
16156  return octave_value_list();
16157 }
16158 
16159 
16161  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16162  void *argp1 = 0 ;
16163  int res1 = 0 ;
16164  octave_value_list _out;
16165  octave_value_list *_outp=&_out;
16166  octave_value _outv;
16167  PLFLT result;
16168 
16169  if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
16170  SWIG_fail;
16171  }
16172  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16173  if (!SWIG_IsOK(res1)) {
16174  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16175  }
16176  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16177  result = (PLFLT) ((arg1)->wY);
16178  _outv = SWIG_From_double(static_cast< double >(result));
16179  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16180  return _out;
16181 fail:
16182  return octave_value_list();
16183 }
16184 
16185 
16187  octave_value_list _out;
16188  octave_value_list *_outp=&_out;
16189  octave_value _outv;
16190  PLGraphicsIn *result = 0 ;
16191 
16192  if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
16193  SWIG_fail;
16194  }
16195  result = (PLGraphicsIn *)new PLGraphicsIn();
16197  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16198  return _out;
16199 fail:
16200  return octave_value_list();
16201 }
16202 
16203 
16205  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16206  void *argp1 = 0 ;
16207  int res1 = 0 ;
16208  octave_value_list _out;
16209  octave_value_list *_outp=&_out;
16210  octave_value _outv;
16211 
16212  if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
16213  SWIG_fail;
16214  }
16215  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
16216  if (!SWIG_IsOK(res1)) {
16217  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16218  }
16219  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16220  delete arg1;
16221  _outv = octave_value();
16222  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16223  return _out;
16224 fail:
16225  return octave_value_list();
16226 }
16227 
16228 
16242 {0,0,0,0,0,0}
16243 };
16244 static const char *swig_PLGraphicsIn_base_names[] = {0};
16247 
16249  PLINT arg1 ;
16250  PLINT arg2 ;
16251  int val1 ;
16252  int ecode1 = 0 ;
16253  int val2 ;
16254  int ecode2 = 0 ;
16255  octave_value_list _out;
16256  octave_value_list *_outp=&_out;
16257  octave_value _outv;
16258 
16259  if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
16260  SWIG_fail;
16261  }
16262  ecode1 = SWIG_AsVal_int(args(0), &val1);
16263  if (!SWIG_IsOK(ecode1)) {
16264  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
16265  }
16266  arg1 = static_cast< PLINT >(val1);
16267  ecode2 = SWIG_AsVal_int(args(1), &val2);
16268  if (!SWIG_IsOK(ecode2)) {
16269  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
16270  }
16271  arg2 = static_cast< PLINT >(val2);
16272  pl_setcontlabelformat(arg1,arg2);
16273  _outv = octave_value();
16274  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16275  return _out;
16276 fail:
16277  return octave_value_list();
16278 }
16279 
16280 
16282  PLFLT arg1 ;
16283  PLFLT arg2 ;
16284  PLFLT arg3 ;
16285  PLINT arg4 ;
16286  double val1 ;
16287  int ecode1 = 0 ;
16288  double val2 ;
16289  int ecode2 = 0 ;
16290  double val3 ;
16291  int ecode3 = 0 ;
16292  int val4 ;
16293  int ecode4 = 0 ;
16294  octave_value_list _out;
16295  octave_value_list *_outp=&_out;
16296  octave_value _outv;
16297 
16298  if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
16299  SWIG_fail;
16300  }
16301  ecode1 = SWIG_AsVal_double(args(0), &val1);
16302  if (!SWIG_IsOK(ecode1)) {
16303  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
16304  }
16305  arg1 = static_cast< PLFLT >(val1);
16306  ecode2 = SWIG_AsVal_double(args(1), &val2);
16307  if (!SWIG_IsOK(ecode2)) {
16308  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
16309  }
16310  arg2 = static_cast< PLFLT >(val2);
16311  ecode3 = SWIG_AsVal_double(args(2), &val3);
16312  if (!SWIG_IsOK(ecode3)) {
16313  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
16314  }
16315  arg3 = static_cast< PLFLT >(val3);
16316  ecode4 = SWIG_AsVal_int(args(3), &val4);
16317  if (!SWIG_IsOK(ecode4)) {
16318  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
16319  }
16320  arg4 = static_cast< PLINT >(val4);
16321  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
16322  _outv = octave_value();
16323  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16324  return _out;
16325 fail:
16326  return octave_value_list();
16327 }
16328 
16329 
16331  PLINT arg1 ;
16332  int val1 ;
16333  int ecode1 = 0 ;
16334  octave_value_list _out;
16335  octave_value_list *_outp=&_out;
16336  octave_value _outv;
16337 
16338  if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
16339  SWIG_fail;
16340  }
16341  ecode1 = SWIG_AsVal_int(args(0), &val1);
16342  if (!SWIG_IsOK(ecode1)) {
16343  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
16344  }
16345  arg1 = static_cast< PLINT >(val1);
16346  pladv(arg1);
16347  _outv = octave_value();
16348  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16349  return _out;
16350 fail:
16351  return octave_value_list();
16352 }
16353 
16354 
16356  PLFLT arg1 ;
16357  PLFLT arg2 ;
16358  PLFLT arg3 ;
16359  PLFLT arg4 ;
16360  PLFLT arg5 ;
16361  PLFLT arg6 ;
16362  PLFLT arg7 ;
16363  PLBOOL arg8 ;
16364  double val1 ;
16365  int ecode1 = 0 ;
16366  double val2 ;
16367  int ecode2 = 0 ;
16368  double val3 ;
16369  int ecode3 = 0 ;
16370  double val4 ;
16371  int ecode4 = 0 ;
16372  double val5 ;
16373  int ecode5 = 0 ;
16374  double val6 ;
16375  int ecode6 = 0 ;
16376  double val7 ;
16377  int ecode7 = 0 ;
16378  int val8 ;
16379  int ecode8 = 0 ;
16380  octave_value_list _out;
16381  octave_value_list *_outp=&_out;
16382  octave_value _outv;
16383 
16384  if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
16385  SWIG_fail;
16386  }
16387  ecode1 = SWIG_AsVal_double(args(0), &val1);
16388  if (!SWIG_IsOK(ecode1)) {
16389  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
16390  }
16391  arg1 = static_cast< PLFLT >(val1);
16392  ecode2 = SWIG_AsVal_double(args(1), &val2);
16393  if (!SWIG_IsOK(ecode2)) {
16394  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
16395  }
16396  arg2 = static_cast< PLFLT >(val2);
16397  ecode3 = SWIG_AsVal_double(args(2), &val3);
16398  if (!SWIG_IsOK(ecode3)) {
16399  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
16400  }
16401  arg3 = static_cast< PLFLT >(val3);
16402  ecode4 = SWIG_AsVal_double(args(3), &val4);
16403  if (!SWIG_IsOK(ecode4)) {
16404  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
16405  }
16406  arg4 = static_cast< PLFLT >(val4);
16407  ecode5 = SWIG_AsVal_double(args(4), &val5);
16408  if (!SWIG_IsOK(ecode5)) {
16409  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
16410  }
16411  arg5 = static_cast< PLFLT >(val5);
16412  ecode6 = SWIG_AsVal_double(args(5), &val6);
16413  if (!SWIG_IsOK(ecode6)) {
16414  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
16415  }
16416  arg6 = static_cast< PLFLT >(val6);
16417  ecode7 = SWIG_AsVal_double(args(6), &val7);
16418  if (!SWIG_IsOK(ecode7)) {
16419  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
16420  }
16421  arg7 = static_cast< PLFLT >(val7);
16422  ecode8 = SWIG_AsVal_int(args(7), &val8);
16423  if (!SWIG_IsOK(ecode8)) {
16424  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
16425  }
16426  arg8 = static_cast< PLBOOL >(val8);
16427  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16428  _outv = octave_value();
16429  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16430  return _out;
16431 fail:
16432  return octave_value_list();
16433 }
16434 
16435 
16437  PLFLT arg1 ;
16438  PLFLT arg2 ;
16439  char *arg3 = (char *) 0 ;
16440  PLFLT arg4 ;
16441  PLINT arg5 ;
16442  char *arg6 = (char *) 0 ;
16443  PLFLT arg7 ;
16444  PLINT arg8 ;
16445  double val1 ;
16446  int ecode1 = 0 ;
16447  double val2 ;
16448  int ecode2 = 0 ;
16449  int res3 ;
16450  char *buf3 = 0 ;
16451  int alloc3 = 0 ;
16452  double val4 ;
16453  int ecode4 = 0 ;
16454  int val5 ;
16455  int ecode5 = 0 ;
16456  int res6 ;
16457  char *buf6 = 0 ;
16458  int alloc6 = 0 ;
16459  double val7 ;
16460  int ecode7 = 0 ;
16461  int val8 ;
16462  int ecode8 = 0 ;
16463  octave_value_list _out;
16464  octave_value_list *_outp=&_out;
16465  octave_value _outv;
16466 
16467  if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
16468  SWIG_fail;
16469  }
16470  ecode1 = SWIG_AsVal_double(args(0), &val1);
16471  if (!SWIG_IsOK(ecode1)) {
16472  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
16473  }
16474  arg1 = static_cast< PLFLT >(val1);
16475  ecode2 = SWIG_AsVal_double(args(1), &val2);
16476  if (!SWIG_IsOK(ecode2)) {
16477  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
16478  }
16479  arg2 = static_cast< PLFLT >(val2);
16480  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
16481  if (!SWIG_IsOK(res3)) {
16482  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
16483  }
16484  arg3 = reinterpret_cast< char * >(buf3);
16485  ecode4 = SWIG_AsVal_double(args(3), &val4);
16486  if (!SWIG_IsOK(ecode4)) {
16487  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
16488  }
16489  arg4 = static_cast< PLFLT >(val4);
16490  ecode5 = SWIG_AsVal_int(args(4), &val5);
16491  if (!SWIG_IsOK(ecode5)) {
16492  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
16493  }
16494  arg5 = static_cast< PLINT >(val5);
16495  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
16496  if (!SWIG_IsOK(res6)) {
16497  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
16498  }
16499  arg6 = reinterpret_cast< char * >(buf6);
16500  ecode7 = SWIG_AsVal_double(args(6), &val7);
16501  if (!SWIG_IsOK(ecode7)) {
16502  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
16503  }
16504  arg7 = static_cast< PLFLT >(val7);
16505  ecode8 = SWIG_AsVal_int(args(7), &val8);
16506  if (!SWIG_IsOK(ecode8)) {
16507  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
16508  }
16509  arg8 = static_cast< PLINT >(val8);
16510  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
16511  _outv = octave_value();
16512  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16513  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16514  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16515  return _out;
16516 fail:
16517  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16518  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16519  return octave_value_list();
16520 }
16521 
16522 
16524  PLINT arg1 ;
16525  PLFLT *arg2 = (PLFLT *) 0 ;
16526  PLFLT *arg3 = (PLFLT *) 0 ;
16527  PLINT arg4 ;
16528  Matrix temp1 ;
16529  Matrix temp3 ;
16530  int val4 ;
16531  int ecode4 = 0 ;
16532  octave_value_list _out;
16533  octave_value_list *_outp=&_out;
16534  octave_value _outv;
16535 
16536  if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
16537  SWIG_fail;
16538  }
16539  {
16540  if ( _n_dims( args(0) ) > 1 )
16541  {
16542  error( "argument must be a scalar or vector" ); SWIG_fail;
16543  }
16544  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16545  temp1 = args(0).matrix_value();
16546  arg2 = &temp1( 0, 0 );
16547  }
16548  {
16549  if ( _n_dims( args(1) ) > 1 )
16550  {
16551  error( "argument must be a scalar or vector" ); SWIG_fail;
16552  }
16553  if ( _dim( args(1), 0 ) != Alen )
16554  {
16555  error( "argument vectors must be same length" ); SWIG_fail;
16556  }
16557  temp3 = args(1).matrix_value();
16558  arg3 = &temp3( 0, 0 );
16559  }
16560  ecode4 = SWIG_AsVal_int(args(2), &val4);
16561  if (!SWIG_IsOK(ecode4)) {
16562  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
16563  }
16564  arg4 = static_cast< PLINT >(val4);
16565  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
16566  _outv = octave_value();
16567  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16568  {
16569 
16570  }
16571  {
16572 
16573  }
16574  return _out;
16575 fail:
16576  {
16577 
16578  }
16579  {
16580 
16581  }
16582  return octave_value_list();
16583 }
16584 
16585 
16587  PLINT *arg1 = (PLINT *) 0 ;
16588  PLINT *arg2 = (PLINT *) 0 ;
16589  PLINT *arg3 = (PLINT *) 0 ;
16590  PLINT *arg4 = (PLINT *) 0 ;
16591  PLINT *arg5 = (PLINT *) 0 ;
16592  PLFLT *arg6 = (PLFLT *) 0 ;
16593  PLFLT arg7 ;
16594  PLINT temp1 ;
16595  int res1 = SWIG_TMPOBJ ;
16596  PLINT temp2 ;
16597  int res2 = SWIG_TMPOBJ ;
16598  PLINT temp3 ;
16599  int res3 = SWIG_TMPOBJ ;
16600  PLINT temp4 ;
16601  int res4 = SWIG_TMPOBJ ;
16602  PLINT temp5 ;
16603  int res5 = SWIG_TMPOBJ ;
16604  PLFLT temp6 ;
16605  int res6 = SWIG_TMPOBJ ;
16606  double val7 ;
16607  int ecode7 = 0 ;
16608  octave_value_list _out;
16609  octave_value_list *_outp=&_out;
16610  octave_value _outv;
16611 
16612  arg1 = &temp1;
16613  arg2 = &temp2;
16614  arg3 = &temp3;
16615  arg4 = &temp4;
16616  arg5 = &temp5;
16617  arg6 = &temp6;
16618  if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
16619  SWIG_fail;
16620  }
16621  ecode7 = SWIG_AsVal_double(args(0), &val7);
16622  if (!SWIG_IsOK(ecode7)) {
16623  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
16624  }
16625  arg7 = static_cast< PLFLT >(val7);
16626  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16627  _outv = octave_value();
16628  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16629  if (SWIG_IsTmpObj(res1)) {
16630  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16631  } else {
16632  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16633  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16634  }
16635  if (SWIG_IsTmpObj(res2)) {
16636  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16637  } else {
16638  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16639  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16640  }
16641  if (SWIG_IsTmpObj(res3)) {
16642  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16643  } else {
16644  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16645  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16646  }
16647  if (SWIG_IsTmpObj(res4)) {
16648  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
16649  } else {
16650  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16651  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16652  }
16653  if (SWIG_IsTmpObj(res5)) {
16654  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
16655  } else {
16656  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16657  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16658  }
16659  if (SWIG_IsTmpObj(res6)) {
16660  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
16661  } else {
16662  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16663  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
16664  }
16665  return _out;
16666 fail:
16667  return octave_value_list();
16668 }
16669 
16670 
16672  octave_value_list _out;
16673  octave_value_list *_outp=&_out;
16674  octave_value _outv;
16675 
16676  if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
16677  SWIG_fail;
16678  }
16679  plbop();
16680  _outv = octave_value();
16681  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16682  return _out;
16683 fail:
16684  return octave_value_list();
16685 }
16686 
16687 
16689  char *arg1 = (char *) 0 ;
16690  PLFLT arg2 ;
16691  PLINT arg3 ;
16692  char *arg4 = (char *) 0 ;
16693  PLFLT arg5 ;
16694  PLINT arg6 ;
16695  int res1 ;
16696  char *buf1 = 0 ;
16697  int alloc1 = 0 ;
16698  double val2 ;
16699  int ecode2 = 0 ;
16700  int val3 ;
16701  int ecode3 = 0 ;
16702  int res4 ;
16703  char *buf4 = 0 ;
16704  int alloc4 = 0 ;
16705  double val5 ;
16706  int ecode5 = 0 ;
16707  int val6 ;
16708  int ecode6 = 0 ;
16709  octave_value_list _out;
16710  octave_value_list *_outp=&_out;
16711  octave_value _outv;
16712 
16713  if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
16714  SWIG_fail;
16715  }
16716  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16717  if (!SWIG_IsOK(res1)) {
16718  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
16719  }
16720  arg1 = reinterpret_cast< char * >(buf1);
16721  ecode2 = SWIG_AsVal_double(args(1), &val2);
16722  if (!SWIG_IsOK(ecode2)) {
16723  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
16724  }
16725  arg2 = static_cast< PLFLT >(val2);
16726  ecode3 = SWIG_AsVal_int(args(2), &val3);
16727  if (!SWIG_IsOK(ecode3)) {
16728  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
16729  }
16730  arg3 = static_cast< PLINT >(val3);
16731  res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
16732  if (!SWIG_IsOK(res4)) {
16733  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
16734  }
16735  arg4 = reinterpret_cast< char * >(buf4);
16736  ecode5 = SWIG_AsVal_double(args(4), &val5);
16737  if (!SWIG_IsOK(ecode5)) {
16738  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
16739  }
16740  arg5 = static_cast< PLFLT >(val5);
16741  ecode6 = SWIG_AsVal_int(args(5), &val6);
16742  if (!SWIG_IsOK(ecode6)) {
16743  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
16744  }
16745  arg6 = static_cast< PLINT >(val6);
16746  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
16747  _outv = octave_value();
16748  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16749  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16750  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
16751  return _out;
16752 fail:
16753  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16754  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
16755  return octave_value_list();
16756 }
16757 
16758 
16760  char *arg1 = (char *) 0 ;
16761  char *arg2 = (char *) 0 ;
16762  PLFLT arg3 ;
16763  PLINT arg4 ;
16764  char *arg5 = (char *) 0 ;
16765  char *arg6 = (char *) 0 ;
16766  PLFLT arg7 ;
16767  PLINT arg8 ;
16768  char *arg9 = (char *) 0 ;
16769  char *arg10 = (char *) 0 ;
16770  PLFLT arg11 ;
16771  PLINT arg12 ;
16772  int res1 ;
16773  char *buf1 = 0 ;
16774  int alloc1 = 0 ;
16775  int res2 ;
16776  char *buf2 = 0 ;
16777  int alloc2 = 0 ;
16778  double val3 ;
16779  int ecode3 = 0 ;
16780  int val4 ;
16781  int ecode4 = 0 ;
16782  int res5 ;
16783  char *buf5 = 0 ;
16784  int alloc5 = 0 ;
16785  int res6 ;
16786  char *buf6 = 0 ;
16787  int alloc6 = 0 ;
16788  double val7 ;
16789  int ecode7 = 0 ;
16790  int val8 ;
16791  int ecode8 = 0 ;
16792  int res9 ;
16793  char *buf9 = 0 ;
16794  int alloc9 = 0 ;
16795  int res10 ;
16796  char *buf10 = 0 ;
16797  int alloc10 = 0 ;
16798  double val11 ;
16799  int ecode11 = 0 ;
16800  int val12 ;
16801  int ecode12 = 0 ;
16802  octave_value_list _out;
16803  octave_value_list *_outp=&_out;
16804  octave_value _outv;
16805 
16806  if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
16807  SWIG_fail;
16808  }
16809  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16810  if (!SWIG_IsOK(res1)) {
16811  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
16812  }
16813  arg1 = reinterpret_cast< char * >(buf1);
16814  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
16815  if (!SWIG_IsOK(res2)) {
16816  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
16817  }
16818  arg2 = reinterpret_cast< char * >(buf2);
16819  ecode3 = SWIG_AsVal_double(args(2), &val3);
16820  if (!SWIG_IsOK(ecode3)) {
16821  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
16822  }
16823  arg3 = static_cast< PLFLT >(val3);
16824  ecode4 = SWIG_AsVal_int(args(3), &val4);
16825  if (!SWIG_IsOK(ecode4)) {
16826  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
16827  }
16828  arg4 = static_cast< PLINT >(val4);
16829  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
16830  if (!SWIG_IsOK(res5)) {
16831  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
16832  }
16833  arg5 = reinterpret_cast< char * >(buf5);
16834  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
16835  if (!SWIG_IsOK(res6)) {
16836  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
16837  }
16838  arg6 = reinterpret_cast< char * >(buf6);
16839  ecode7 = SWIG_AsVal_double(args(6), &val7);
16840  if (!SWIG_IsOK(ecode7)) {
16841  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
16842  }
16843  arg7 = static_cast< PLFLT >(val7);
16844  ecode8 = SWIG_AsVal_int(args(7), &val8);
16845  if (!SWIG_IsOK(ecode8)) {
16846  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
16847  }
16848  arg8 = static_cast< PLINT >(val8);
16849  res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
16850  if (!SWIG_IsOK(res9)) {
16851  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
16852  }
16853  arg9 = reinterpret_cast< char * >(buf9);
16854  res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
16855  if (!SWIG_IsOK(res10)) {
16856  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
16857  }
16858  arg10 = reinterpret_cast< char * >(buf10);
16859  ecode11 = SWIG_AsVal_double(args(10), &val11);
16860  if (!SWIG_IsOK(ecode11)) {
16861  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
16862  }
16863  arg11 = static_cast< PLFLT >(val11);
16864  ecode12 = SWIG_AsVal_int(args(11), &val12);
16865  if (!SWIG_IsOK(ecode12)) {
16866  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
16867  }
16868  arg12 = static_cast< PLINT >(val12);
16869  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);
16870  _outv = octave_value();
16871  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16872  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16873  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16874  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16875  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16876  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
16877  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
16878  return _out;
16879 fail:
16880  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16881  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16882  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16883  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16884  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
16885  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
16886  return octave_value_list();
16887 }
16888 
16889 
16891  PLFLT arg1 ;
16892  PLFLT arg2 ;
16893  PLFLT *arg3 = (PLFLT *) 0 ;
16894  PLFLT *arg4 = (PLFLT *) 0 ;
16895  PLINT *arg5 = (PLINT *) 0 ;
16896  double val1 ;
16897  int ecode1 = 0 ;
16898  double val2 ;
16899  int ecode2 = 0 ;
16900  PLFLT temp3 ;
16901  int res3 = SWIG_TMPOBJ ;
16902  PLFLT temp4 ;
16903  int res4 = SWIG_TMPOBJ ;
16904  PLINT temp5 ;
16905  int res5 = SWIG_TMPOBJ ;
16906  octave_value_list _out;
16907  octave_value_list *_outp=&_out;
16908  octave_value _outv;
16909 
16910  arg3 = &temp3;
16911  arg4 = &temp4;
16912  arg5 = &temp5;
16913  if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
16914  SWIG_fail;
16915  }
16916  ecode1 = SWIG_AsVal_double(args(0), &val1);
16917  if (!SWIG_IsOK(ecode1)) {
16918  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
16919  }
16920  arg1 = static_cast< PLFLT >(val1);
16921  ecode2 = SWIG_AsVal_double(args(1), &val2);
16922  if (!SWIG_IsOK(ecode2)) {
16923  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
16924  }
16925  arg2 = static_cast< PLFLT >(val2);
16926  plcalc_world(arg1,arg2,arg3,arg4,arg5);
16927  _outv = octave_value();
16928  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16929  if (SWIG_IsTmpObj(res3)) {
16930  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
16931  } else {
16932  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16933  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
16934  }
16935  if (SWIG_IsTmpObj(res4)) {
16936  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
16937  } else {
16938  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16939  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
16940  }
16941  if (SWIG_IsTmpObj(res5)) {
16942  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
16943  } else {
16944  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16945  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16946  }
16947  return _out;
16948 fail:
16949  return octave_value_list();
16950 }
16951 
16952 
16954  octave_value_list _out;
16955  octave_value_list *_outp=&_out;
16956  octave_value _outv;
16957 
16958  if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
16959  SWIG_fail;
16960  }
16961  plclear();
16962  _outv = octave_value();
16963  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16964  return _out;
16965 fail:
16966  return octave_value_list();
16967 }
16968 
16969 
16971  PLINT arg1 ;
16972  int val1 ;
16973  int ecode1 = 0 ;
16974  octave_value_list _out;
16975  octave_value_list *_outp=&_out;
16976  octave_value _outv;
16977 
16978  if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
16979  SWIG_fail;
16980  }
16981  ecode1 = SWIG_AsVal_int(args(0), &val1);
16982  if (!SWIG_IsOK(ecode1)) {
16983  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
16984  }
16985  arg1 = static_cast< PLINT >(val1);
16986  plcol0(arg1);
16987  _outv = octave_value();
16988  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16989  return _out;
16990 fail:
16991  return octave_value_list();
16992 }
16993 
16994 
16996  PLFLT arg1 ;
16997  double val1 ;
16998  int ecode1 = 0 ;
16999  octave_value_list _out;
17000  octave_value_list *_outp=&_out;
17001  octave_value _outv;
17002 
17003  if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17004  SWIG_fail;
17005  }
17006  ecode1 = SWIG_AsVal_double(args(0), &val1);
17007  if (!SWIG_IsOK(ecode1)) {
17008  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17009  }
17010  arg1 = static_cast< PLFLT >(val1);
17011  plcol1(arg1);
17012  _outv = octave_value();
17013  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17014  return _out;
17015 fail:
17016  return octave_value_list();
17017 }
17018 
17019 
17021  PLFLT arg1 ;
17022  PLFLT arg2 ;
17023  PLFLT arg3 ;
17024  PLINT arg4 ;
17025  PLBOOL arg5 ;
17026  PLINT arg6 ;
17027  PLINT arg7 ;
17028  PLINT arg8 ;
17029  PLINT arg9 ;
17030  PLINT arg10 ;
17031  PLFLT arg11 ;
17032  double val1 ;
17033  int ecode1 = 0 ;
17034  double val2 ;
17035  int ecode2 = 0 ;
17036  double val3 ;
17037  int ecode3 = 0 ;
17038  int val4 ;
17039  int ecode4 = 0 ;
17040  int val5 ;
17041  int ecode5 = 0 ;
17042  int val6 ;
17043  int ecode6 = 0 ;
17044  int val7 ;
17045  int ecode7 = 0 ;
17046  int val8 ;
17047  int ecode8 = 0 ;
17048  int val9 ;
17049  int ecode9 = 0 ;
17050  int val10 ;
17051  int ecode10 = 0 ;
17052  double val11 ;
17053  int ecode11 = 0 ;
17054  octave_value_list _out;
17055  octave_value_list *_outp=&_out;
17056  octave_value _outv;
17057 
17058  if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
17059  SWIG_fail;
17060  }
17061  ecode1 = SWIG_AsVal_double(args(0), &val1);
17062  if (!SWIG_IsOK(ecode1)) {
17063  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
17064  }
17065  arg1 = static_cast< PLFLT >(val1);
17066  ecode2 = SWIG_AsVal_double(args(1), &val2);
17067  if (!SWIG_IsOK(ecode2)) {
17068  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
17069  }
17070  arg2 = static_cast< PLFLT >(val2);
17071  ecode3 = SWIG_AsVal_double(args(2), &val3);
17072  if (!SWIG_IsOK(ecode3)) {
17073  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
17074  }
17075  arg3 = static_cast< PLFLT >(val3);
17076  ecode4 = SWIG_AsVal_int(args(3), &val4);
17077  if (!SWIG_IsOK(ecode4)) {
17078  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
17079  }
17080  arg4 = static_cast< PLINT >(val4);
17081  ecode5 = SWIG_AsVal_int(args(4), &val5);
17082  if (!SWIG_IsOK(ecode5)) {
17083  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
17084  }
17085  arg5 = static_cast< PLBOOL >(val5);
17086  ecode6 = SWIG_AsVal_int(args(5), &val6);
17087  if (!SWIG_IsOK(ecode6)) {
17088  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
17089  }
17090  arg6 = static_cast< PLINT >(val6);
17091  ecode7 = SWIG_AsVal_int(args(6), &val7);
17092  if (!SWIG_IsOK(ecode7)) {
17093  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
17094  }
17095  arg7 = static_cast< PLINT >(val7);
17096  ecode8 = SWIG_AsVal_int(args(7), &val8);
17097  if (!SWIG_IsOK(ecode8)) {
17098  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
17099  }
17100  arg8 = static_cast< PLINT >(val8);
17101  ecode9 = SWIG_AsVal_int(args(8), &val9);
17102  if (!SWIG_IsOK(ecode9)) {
17103  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
17104  }
17105  arg9 = static_cast< PLINT >(val9);
17106  ecode10 = SWIG_AsVal_int(args(9), &val10);
17107  if (!SWIG_IsOK(ecode10)) {
17108  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
17109  }
17110  arg10 = static_cast< PLINT >(val10);
17111  ecode11 = SWIG_AsVal_double(args(10), &val11);
17112  if (!SWIG_IsOK(ecode11)) {
17113  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
17114  }
17115  arg11 = static_cast< PLFLT >(val11);
17116  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
17117  _outv = octave_value();
17118  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17119  return _out;
17120 fail:
17121  return octave_value_list();
17122 }
17123 
17124 
17126  PLINT arg1 ;
17127  PLINT arg2 ;
17128  PLINT arg3 ;
17129  PLINT arg4 ;
17130  PLINT arg5 ;
17131  PLFLT arg6 ;
17132  PLFLT *arg7 = (PLFLT *) 0 ;
17133  int val1 ;
17134  int ecode1 = 0 ;
17135  int val2 ;
17136  int ecode2 = 0 ;
17137  int val3 ;
17138  int ecode3 = 0 ;
17139  int val4 ;
17140  int ecode4 = 0 ;
17141  int val5 ;
17142  int ecode5 = 0 ;
17143  double val6 ;
17144  int ecode6 = 0 ;
17145  PLFLT temp7 ;
17146  int res7 = SWIG_TMPOBJ ;
17147  octave_value_list _out;
17148  octave_value_list *_outp=&_out;
17149  octave_value _outv;
17150 
17151  arg7 = &temp7;
17152  if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
17153  SWIG_fail;
17154  }
17155  ecode1 = SWIG_AsVal_int(args(0), &val1);
17156  if (!SWIG_IsOK(ecode1)) {
17157  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
17158  }
17159  arg1 = static_cast< PLINT >(val1);
17160  ecode2 = SWIG_AsVal_int(args(1), &val2);
17161  if (!SWIG_IsOK(ecode2)) {
17162  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
17163  }
17164  arg2 = static_cast< PLINT >(val2);
17165  ecode3 = SWIG_AsVal_int(args(2), &val3);
17166  if (!SWIG_IsOK(ecode3)) {
17167  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
17168  }
17169  arg3 = static_cast< PLINT >(val3);
17170  ecode4 = SWIG_AsVal_int(args(3), &val4);
17171  if (!SWIG_IsOK(ecode4)) {
17172  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
17173  }
17174  arg4 = static_cast< PLINT >(val4);
17175  ecode5 = SWIG_AsVal_int(args(4), &val5);
17176  if (!SWIG_IsOK(ecode5)) {
17177  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
17178  }
17179  arg5 = static_cast< PLINT >(val5);
17180  ecode6 = SWIG_AsVal_double(args(5), &val6);
17181  if (!SWIG_IsOK(ecode6)) {
17182  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
17183  }
17184  arg6 = static_cast< PLFLT >(val6);
17185  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17186  _outv = octave_value();
17187  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17188  if (SWIG_IsTmpObj(res7)) {
17189  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
17190  } else {
17191  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17192  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
17193  }
17194  return _out;
17195 fail:
17196  return octave_value_list();
17197 }
17198 
17199 
17201  PLINT arg1 ;
17202  PLBOOL arg2 ;
17203  int val1 ;
17204  int ecode1 = 0 ;
17205  int val2 ;
17206  int ecode2 = 0 ;
17207  octave_value_list _out;
17208  octave_value_list *_outp=&_out;
17209  octave_value _outv;
17210 
17211  if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
17212  SWIG_fail;
17213  }
17214  ecode1 = SWIG_AsVal_int(args(0), &val1);
17215  if (!SWIG_IsOK(ecode1)) {
17216  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
17217  }
17218  arg1 = static_cast< PLINT >(val1);
17219  ecode2 = SWIG_AsVal_int(args(1), &val2);
17220  if (!SWIG_IsOK(ecode2)) {
17221  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
17222  }
17223  arg2 = static_cast< PLBOOL >(val2);
17224  plcpstrm(arg1,arg2);
17225  _outv = octave_value();
17226  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17227  return _out;
17228 fail:
17229  return octave_value_list();
17230 }
17231 
17232 
17234  octave_value_list _out;
17235  octave_value_list *_outp=&_out;
17236  octave_value _outv;
17237 
17238  if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
17239  SWIG_fail;
17240  }
17241  plend();
17242  _outv = octave_value();
17243  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17244  return _out;
17245 fail:
17246  return octave_value_list();
17247 }
17248 
17249 
17251  octave_value_list _out;
17252  octave_value_list *_outp=&_out;
17253  octave_value _outv;
17254 
17255  if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
17256  SWIG_fail;
17257  }
17258  plend1();
17259  _outv = octave_value();
17260  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17261  return _out;
17262 fail:
17263  return octave_value_list();
17264 }
17265 
17266 
17268  PLFLT arg1 ;
17269  PLFLT arg2 ;
17270  PLFLT arg3 ;
17271  PLFLT arg4 ;
17272  PLINT arg5 ;
17273  PLINT arg6 ;
17274  double val1 ;
17275  int ecode1 = 0 ;
17276  double val2 ;
17277  int ecode2 = 0 ;
17278  double val3 ;
17279  int ecode3 = 0 ;
17280  double val4 ;
17281  int ecode4 = 0 ;
17282  int val5 ;
17283  int ecode5 = 0 ;
17284  int val6 ;
17285  int ecode6 = 0 ;
17286  octave_value_list _out;
17287  octave_value_list *_outp=&_out;
17288  octave_value _outv;
17289 
17290  if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
17291  SWIG_fail;
17292  }
17293  ecode1 = SWIG_AsVal_double(args(0), &val1);
17294  if (!SWIG_IsOK(ecode1)) {
17295  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
17296  }
17297  arg1 = static_cast< PLFLT >(val1);
17298  ecode2 = SWIG_AsVal_double(args(1), &val2);
17299  if (!SWIG_IsOK(ecode2)) {
17300  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
17301  }
17302  arg2 = static_cast< PLFLT >(val2);
17303  ecode3 = SWIG_AsVal_double(args(2), &val3);
17304  if (!SWIG_IsOK(ecode3)) {
17305  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
17306  }
17307  arg3 = static_cast< PLFLT >(val3);
17308  ecode4 = SWIG_AsVal_double(args(3), &val4);
17309  if (!SWIG_IsOK(ecode4)) {
17310  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
17311  }
17312  arg4 = static_cast< PLFLT >(val4);
17313  ecode5 = SWIG_AsVal_int(args(4), &val5);
17314  if (!SWIG_IsOK(ecode5)) {
17315  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
17316  }
17317  arg5 = static_cast< PLINT >(val5);
17318  ecode6 = SWIG_AsVal_int(args(5), &val6);
17319  if (!SWIG_IsOK(ecode6)) {
17320  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
17321  }
17322  arg6 = static_cast< PLINT >(val6);
17323  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
17324  _outv = octave_value();
17325  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17326  return _out;
17327 fail:
17328  return octave_value_list();
17329 }
17330 
17331 
17333  PLFLT arg1 ;
17334  PLFLT arg2 ;
17335  PLFLT arg3 ;
17336  PLFLT arg4 ;
17337  PLINT arg5 ;
17338  PLINT arg6 ;
17339  double val1 ;
17340  int ecode1 = 0 ;
17341  double val2 ;
17342  int ecode2 = 0 ;
17343  double val3 ;
17344  int ecode3 = 0 ;
17345  double val4 ;
17346  int ecode4 = 0 ;
17347  int val5 ;
17348  int ecode5 = 0 ;
17349  int val6 ;
17350  int ecode6 = 0 ;
17351  octave_value_list _out;
17352  octave_value_list *_outp=&_out;
17353  octave_value _outv;
17354 
17355  if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
17356  SWIG_fail;
17357  }
17358  ecode1 = SWIG_AsVal_double(args(0), &val1);
17359  if (!SWIG_IsOK(ecode1)) {
17360  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
17361  }
17362  arg1 = static_cast< PLFLT >(val1);
17363  ecode2 = SWIG_AsVal_double(args(1), &val2);
17364  if (!SWIG_IsOK(ecode2)) {
17365  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
17366  }
17367  arg2 = static_cast< PLFLT >(val2);
17368  ecode3 = SWIG_AsVal_double(args(2), &val3);
17369  if (!SWIG_IsOK(ecode3)) {
17370  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
17371  }
17372  arg3 = static_cast< PLFLT >(val3);
17373  ecode4 = SWIG_AsVal_double(args(3), &val4);
17374  if (!SWIG_IsOK(ecode4)) {
17375  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
17376  }
17377  arg4 = static_cast< PLFLT >(val4);
17378  ecode5 = SWIG_AsVal_int(args(4), &val5);
17379  if (!SWIG_IsOK(ecode5)) {
17380  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
17381  }
17382  arg5 = static_cast< PLINT >(val5);
17383  ecode6 = SWIG_AsVal_int(args(5), &val6);
17384  if (!SWIG_IsOK(ecode6)) {
17385  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
17386  }
17387  arg6 = static_cast< PLINT >(val6);
17388  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
17389  _outv = octave_value();
17390  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17391  return _out;
17392 fail:
17393  return octave_value_list();
17394 }
17395 
17396 
17398  octave_value_list _out;
17399  octave_value_list *_outp=&_out;
17400  octave_value _outv;
17401 
17402  if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
17403  SWIG_fail;
17404  }
17405  pleop();
17406  _outv = octave_value();
17407  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17408  return _out;
17409 fail:
17410  return octave_value_list();
17411 }
17412 
17413 
17415  PLINT arg1 ;
17416  PLFLT *arg2 = (PLFLT *) 0 ;
17417  PLFLT *arg3 = (PLFLT *) 0 ;
17418  PLFLT *arg4 = (PLFLT *) 0 ;
17419  Matrix temp1 ;
17420  Matrix temp3 ;
17421  Matrix temp4 ;
17422  octave_value_list _out;
17423  octave_value_list *_outp=&_out;
17424  octave_value _outv;
17425 
17426  if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
17427  SWIG_fail;
17428  }
17429  {
17430  if ( _n_dims( args(0) ) > 1 )
17431  {
17432  error( "argument must be a scalar or vector" ); SWIG_fail;
17433  }
17434  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17435  temp1 = args(0).matrix_value();
17436  arg2 = &temp1( 0, 0 );
17437  }
17438  {
17439  if ( _n_dims( args(1) ) > 1 )
17440  {
17441  error( "argument must be a scalar or vector" ); SWIG_fail;
17442  }
17443  if ( _dim( args(1), 0 ) != Alen )
17444  {
17445  error( "argument vectors must be same length" ); SWIG_fail;
17446  }
17447  temp3 = args(1).matrix_value();
17448  arg3 = &temp3( 0, 0 );
17449  }
17450  {
17451  if ( _n_dims( args(2) ) > 1 )
17452  {
17453  error( "argument must be a scalar or vector" ); SWIG_fail;
17454  }
17455  if ( _dim( args(2), 0 ) != Alen )
17456  {
17457  error( "argument vectors must be same length" ); SWIG_fail;
17458  }
17459  temp4 = args(2).matrix_value();
17460  arg4 = &temp4( 0, 0 );
17461  }
17462  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17463  _outv = octave_value();
17464  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17465  {
17466 
17467  }
17468  {
17469 
17470  }
17471  {
17472 
17473  }
17474  return _out;
17475 fail:
17476  {
17477 
17478  }
17479  {
17480 
17481  }
17482  {
17483 
17484  }
17485  return octave_value_list();
17486 }
17487 
17488 
17490  PLINT arg1 ;
17491  PLFLT *arg2 = (PLFLT *) 0 ;
17492  PLFLT *arg3 = (PLFLT *) 0 ;
17493  PLFLT *arg4 = (PLFLT *) 0 ;
17494  Matrix temp1 ;
17495  Matrix temp3 ;
17496  Matrix temp4 ;
17497  octave_value_list _out;
17498  octave_value_list *_outp=&_out;
17499  octave_value _outv;
17500 
17501  if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
17502  SWIG_fail;
17503  }
17504  {
17505  if ( _n_dims( args(0) ) > 1 )
17506  {
17507  error( "argument must be a scalar or vector" ); SWIG_fail;
17508  }
17509  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17510  temp1 = args(0).matrix_value();
17511  arg2 = &temp1( 0, 0 );
17512  }
17513  {
17514  if ( _n_dims( args(1) ) > 1 )
17515  {
17516  error( "argument must be a scalar or vector" ); SWIG_fail;
17517  }
17518  if ( _dim( args(1), 0 ) != Alen )
17519  {
17520  error( "argument vectors must be same length" ); SWIG_fail;
17521  }
17522  temp3 = args(1).matrix_value();
17523  arg3 = &temp3( 0, 0 );
17524  }
17525  {
17526  if ( _n_dims( args(2) ) > 1 )
17527  {
17528  error( "argument must be a scalar or vector" ); SWIG_fail;
17529  }
17530  if ( _dim( args(2), 0 ) != Alen )
17531  {
17532  error( "argument vectors must be same length" ); SWIG_fail;
17533  }
17534  temp4 = args(2).matrix_value();
17535  arg4 = &temp4( 0, 0 );
17536  }
17537  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17538  _outv = octave_value();
17539  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17540  {
17541 
17542  }
17543  {
17544 
17545  }
17546  {
17547 
17548  }
17549  return _out;
17550 fail:
17551  {
17552 
17553  }
17554  {
17555 
17556  }
17557  {
17558 
17559  }
17560  return octave_value_list();
17561 }
17562 
17563 
17565  octave_value_list _out;
17566  octave_value_list *_outp=&_out;
17567  octave_value _outv;
17568 
17569  if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
17570  SWIG_fail;
17571  }
17572  plfamadv();
17573  _outv = octave_value();
17574  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17575  return _out;
17576 fail:
17577  return octave_value_list();
17578 }
17579 
17580 
17582  PLINT arg1 ;
17583  PLFLT *arg2 = (PLFLT *) 0 ;
17584  PLFLT *arg3 = (PLFLT *) 0 ;
17585  Matrix temp1 ;
17586  Matrix temp3 ;
17587  octave_value_list _out;
17588  octave_value_list *_outp=&_out;
17589  octave_value _outv;
17590 
17591  if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
17592  SWIG_fail;
17593  }
17594  {
17595  if ( _n_dims( args(0) ) > 1 )
17596  {
17597  error( "argument must be a scalar or vector" ); SWIG_fail;
17598  }
17599  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17600  temp1 = args(0).matrix_value();
17601  arg2 = &temp1( 0, 0 );
17602  }
17603  {
17604  if ( _n_dims( args(1) ) > 1 )
17605  {
17606  error( "argument must be a scalar or vector" ); SWIG_fail;
17607  }
17608  if ( _dim( args(1), 0 ) != Alen )
17609  {
17610  error( "argument vectors must be same length" ); SWIG_fail;
17611  }
17612  temp3 = args(1).matrix_value();
17613  arg3 = &temp3( 0, 0 );
17614  }
17615  plfill(arg1,(double const *)arg2,(double const *)arg3);
17616  _outv = octave_value();
17617  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17618  {
17619 
17620  }
17621  {
17622 
17623  }
17624  return _out;
17625 fail:
17626  {
17627 
17628  }
17629  {
17630 
17631  }
17632  return octave_value_list();
17633 }
17634 
17635 
17637  PLINT arg1 ;
17638  PLFLT *arg2 = (PLFLT *) 0 ;
17639  PLFLT *arg3 = (PLFLT *) 0 ;
17640  PLFLT *arg4 = (PLFLT *) 0 ;
17641  Matrix temp1 ;
17642  Matrix temp3 ;
17643  Matrix temp4 ;
17644  octave_value_list _out;
17645  octave_value_list *_outp=&_out;
17646  octave_value _outv;
17647 
17648  if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
17649  SWIG_fail;
17650  }
17651  {
17652  if ( _n_dims( args(0) ) > 1 )
17653  {
17654  error( "argument must be a scalar or vector" ); SWIG_fail;
17655  }
17656  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17657  temp1 = args(0).matrix_value();
17658  arg2 = &temp1( 0, 0 );
17659  }
17660  {
17661  if ( _n_dims( args(1) ) > 1 )
17662  {
17663  error( "argument must be a scalar or vector" ); SWIG_fail;
17664  }
17665  if ( _dim( args(1), 0 ) != Alen )
17666  {
17667  error( "argument vectors must be same length" ); SWIG_fail;
17668  }
17669  temp3 = args(1).matrix_value();
17670  arg3 = &temp3( 0, 0 );
17671  }
17672  {
17673  if ( _n_dims( args(2) ) > 1 )
17674  {
17675  error( "argument must be a scalar or vector" ); SWIG_fail;
17676  }
17677  if ( _dim( args(2), 0 ) != Alen )
17678  {
17679  error( "argument vectors must be same length" ); SWIG_fail;
17680  }
17681  temp4 = args(2).matrix_value();
17682  arg4 = &temp4( 0, 0 );
17683  }
17684  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17685  _outv = octave_value();
17686  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17687  {
17688 
17689  }
17690  {
17691 
17692  }
17693  {
17694 
17695  }
17696  return _out;
17697 fail:
17698  {
17699 
17700  }
17701  {
17702 
17703  }
17704  {
17705 
17706  }
17707  return octave_value_list();
17708 }
17709 
17710 
17712  PLINT arg1 ;
17713  PLFLT *arg2 = (PLFLT *) 0 ;
17714  PLFLT *arg3 = (PLFLT *) 0 ;
17715  PLFLT arg4 ;
17716  Matrix temp1 ;
17717  Matrix temp3 ;
17718  double val4 ;
17719  int ecode4 = 0 ;
17720  octave_value_list _out;
17721  octave_value_list *_outp=&_out;
17722  octave_value _outv;
17723 
17724  if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
17725  SWIG_fail;
17726  }
17727  {
17728  if ( _n_dims( args(0) ) > 1 )
17729  {
17730  error( "argument must be a scalar or vector" ); SWIG_fail;
17731  }
17732  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17733  temp1 = args(0).matrix_value();
17734  arg2 = &temp1( 0, 0 );
17735  }
17736  {
17737  if ( _n_dims( args(1) ) > 1 )
17738  {
17739  error( "argument must be a scalar or vector" ); SWIG_fail;
17740  }
17741  if ( _dim( args(1), 0 ) != Alen )
17742  {
17743  error( "argument vectors must be same length" ); SWIG_fail;
17744  }
17745  temp3 = args(1).matrix_value();
17746  arg3 = &temp3( 0, 0 );
17747  }
17748  ecode4 = SWIG_AsVal_double(args(2), &val4);
17749  if (!SWIG_IsOK(ecode4)) {
17750  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
17751  }
17752  arg4 = static_cast< PLFLT >(val4);
17753  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
17754  _outv = octave_value();
17755  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17756  {
17757 
17758  }
17759  {
17760 
17761  }
17762  return _out;
17763 fail:
17764  {
17765 
17766  }
17767  {
17768 
17769  }
17770  return octave_value_list();
17771 }
17772 
17773 
17775  octave_value_list _out;
17776  octave_value_list *_outp=&_out;
17777  octave_value _outv;
17778 
17779  if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
17780  SWIG_fail;
17781  }
17782  plflush();
17783  _outv = octave_value();
17784  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17785  return _out;
17786 fail:
17787  return octave_value_list();
17788 }
17789 
17790 
17792  PLINT arg1 ;
17793  int val1 ;
17794  int ecode1 = 0 ;
17795  octave_value_list _out;
17796  octave_value_list *_outp=&_out;
17797  octave_value _outv;
17798 
17799  if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
17800  SWIG_fail;
17801  }
17802  ecode1 = SWIG_AsVal_int(args(0), &val1);
17803  if (!SWIG_IsOK(ecode1)) {
17804  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
17805  }
17806  arg1 = static_cast< PLINT >(val1);
17807  plfont(arg1);
17808  _outv = octave_value();
17809  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17810  return _out;
17811 fail:
17812  return octave_value_list();
17813 }
17814 
17815 
17817  PLINT arg1 ;
17818  int val1 ;
17819  int ecode1 = 0 ;
17820  octave_value_list _out;
17821  octave_value_list *_outp=&_out;
17822  octave_value _outv;
17823 
17824  if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
17825  SWIG_fail;
17826  }
17827  ecode1 = SWIG_AsVal_int(args(0), &val1);
17828  if (!SWIG_IsOK(ecode1)) {
17829  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
17830  }
17831  arg1 = static_cast< PLINT >(val1);
17832  plfontld(arg1);
17833  _outv = octave_value();
17834  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17835  return _out;
17836 fail:
17837  return octave_value_list();
17838 }
17839 
17840 
17842  PLFLT *arg1 = (PLFLT *) 0 ;
17843  PLFLT *arg2 = (PLFLT *) 0 ;
17844  PLFLT temp1 ;
17845  int res1 = SWIG_TMPOBJ ;
17846  PLFLT temp2 ;
17847  int res2 = SWIG_TMPOBJ ;
17848  octave_value_list _out;
17849  octave_value_list *_outp=&_out;
17850  octave_value _outv;
17851 
17852  arg1 = &temp1;
17853  arg2 = &temp2;
17854  if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
17855  SWIG_fail;
17856  }
17857  plgchr(arg1,arg2);
17858  _outv = octave_value();
17859  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17860  if (SWIG_IsTmpObj(res1)) {
17861  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17862  } else {
17863  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17864  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17865  }
17866  if (SWIG_IsTmpObj(res2)) {
17867  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17868  } else {
17869  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17870  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17871  }
17872  return _out;
17873 fail:
17874  return octave_value_list();
17875 }
17876 
17877 
17879  PLINT arg1 ;
17880  PLINT *arg2 = (PLINT *) 0 ;
17881  PLINT *arg3 = (PLINT *) 0 ;
17882  PLINT *arg4 = (PLINT *) 0 ;
17883  int val1 ;
17884  int ecode1 = 0 ;
17885  PLINT temp2 ;
17886  int res2 = SWIG_TMPOBJ ;
17887  PLINT temp3 ;
17888  int res3 = SWIG_TMPOBJ ;
17889  PLINT temp4 ;
17890  int res4 = SWIG_TMPOBJ ;
17891  octave_value_list _out;
17892  octave_value_list *_outp=&_out;
17893  octave_value _outv;
17894 
17895  arg2 = &temp2;
17896  arg3 = &temp3;
17897  arg4 = &temp4;
17898  if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
17899  SWIG_fail;
17900  }
17901  ecode1 = SWIG_AsVal_int(args(0), &val1);
17902  if (!SWIG_IsOK(ecode1)) {
17903  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
17904  }
17905  arg1 = static_cast< PLINT >(val1);
17906  plgcol0(arg1,arg2,arg3,arg4);
17907  _outv = octave_value();
17908  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17909  if (SWIG_IsTmpObj(res2)) {
17910  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17911  } else {
17912  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17913  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17914  }
17915  if (SWIG_IsTmpObj(res3)) {
17916  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17917  } else {
17918  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17919  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17920  }
17921  if (SWIG_IsTmpObj(res4)) {
17922  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17923  } else {
17924  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17925  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17926  }
17927  return _out;
17928 fail:
17929  return octave_value_list();
17930 }
17931 
17932 
17934  PLINT arg1 ;
17935  PLINT *arg2 = (PLINT *) 0 ;
17936  PLINT *arg3 = (PLINT *) 0 ;
17937  PLINT *arg4 = (PLINT *) 0 ;
17938  PLFLT *arg5 = (PLFLT *) 0 ;
17939  int val1 ;
17940  int ecode1 = 0 ;
17941  PLINT temp2 ;
17942  int res2 = SWIG_TMPOBJ ;
17943  PLINT temp3 ;
17944  int res3 = SWIG_TMPOBJ ;
17945  PLINT temp4 ;
17946  int res4 = SWIG_TMPOBJ ;
17947  PLFLT temp5 ;
17948  int res5 = SWIG_TMPOBJ ;
17949  octave_value_list _out;
17950  octave_value_list *_outp=&_out;
17951  octave_value _outv;
17952 
17953  arg2 = &temp2;
17954  arg3 = &temp3;
17955  arg4 = &temp4;
17956  arg5 = &temp5;
17957  if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
17958  SWIG_fail;
17959  }
17960  ecode1 = SWIG_AsVal_int(args(0), &val1);
17961  if (!SWIG_IsOK(ecode1)) {
17962  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
17963  }
17964  arg1 = static_cast< PLINT >(val1);
17965  plgcol0a(arg1,arg2,arg3,arg4,arg5);
17966  _outv = octave_value();
17967  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17968  if (SWIG_IsTmpObj(res2)) {
17969  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17970  } else {
17971  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17972  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17973  }
17974  if (SWIG_IsTmpObj(res3)) {
17975  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17976  } else {
17977  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17978  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17979  }
17980  if (SWIG_IsTmpObj(res4)) {
17981  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17982  } else {
17983  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17984  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17985  }
17986  if (SWIG_IsTmpObj(res5)) {
17987  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
17988  } else {
17989  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17990  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
17991  }
17992  return _out;
17993 fail:
17994  return octave_value_list();
17995 }
17996 
17997 
17999  PLINT *arg1 = (PLINT *) 0 ;
18000  PLINT *arg2 = (PLINT *) 0 ;
18001  PLINT *arg3 = (PLINT *) 0 ;
18002  PLINT temp1 ;
18003  int res1 = SWIG_TMPOBJ ;
18004  PLINT temp2 ;
18005  int res2 = SWIG_TMPOBJ ;
18006  PLINT temp3 ;
18007  int res3 = SWIG_TMPOBJ ;
18008  octave_value_list _out;
18009  octave_value_list *_outp=&_out;
18010  octave_value _outv;
18011 
18012  arg1 = &temp1;
18013  arg2 = &temp2;
18014  arg3 = &temp3;
18015  if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
18016  SWIG_fail;
18017  }
18018  plgcolbg(arg1,arg2,arg3);
18019  _outv = octave_value();
18020  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18021  if (SWIG_IsTmpObj(res1)) {
18022  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18023  } else {
18024  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18025  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18026  }
18027  if (SWIG_IsTmpObj(res2)) {
18028  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18029  } else {
18030  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18031  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18032  }
18033  if (SWIG_IsTmpObj(res3)) {
18034  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18035  } else {
18036  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18037  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18038  }
18039  return _out;
18040 fail:
18041  return octave_value_list();
18042 }
18043 
18044 
18046  PLINT *arg1 = (PLINT *) 0 ;
18047  PLINT *arg2 = (PLINT *) 0 ;
18048  PLINT *arg3 = (PLINT *) 0 ;
18049  PLFLT *arg4 = (PLFLT *) 0 ;
18050  PLINT temp1 ;
18051  int res1 = SWIG_TMPOBJ ;
18052  PLINT temp2 ;
18053  int res2 = SWIG_TMPOBJ ;
18054  PLINT temp3 ;
18055  int res3 = SWIG_TMPOBJ ;
18056  PLFLT temp4 ;
18057  int res4 = SWIG_TMPOBJ ;
18058  octave_value_list _out;
18059  octave_value_list *_outp=&_out;
18060  octave_value _outv;
18061 
18062  arg1 = &temp1;
18063  arg2 = &temp2;
18064  arg3 = &temp3;
18065  arg4 = &temp4;
18066  if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
18067  SWIG_fail;
18068  }
18069  plgcolbga(arg1,arg2,arg3,arg4);
18070  _outv = octave_value();
18071  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18072  if (SWIG_IsTmpObj(res1)) {
18073  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18074  } else {
18075  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18076  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18077  }
18078  if (SWIG_IsTmpObj(res2)) {
18079  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18080  } else {
18081  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18082  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18083  }
18084  if (SWIG_IsTmpObj(res3)) {
18085  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18086  } else {
18087  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18088  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18089  }
18090  if (SWIG_IsTmpObj(res4)) {
18091  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18092  } else {
18093  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18094  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18095  }
18096  return _out;
18097 fail:
18098  return octave_value_list();
18099 }
18100 
18101 
18103  PLINT *arg1 = (PLINT *) 0 ;
18104  PLINT temp1 ;
18105  int res1 = SWIG_TMPOBJ ;
18106  octave_value_list _out;
18107  octave_value_list *_outp=&_out;
18108  octave_value _outv;
18109 
18110  arg1 = &temp1;
18111  if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
18112  SWIG_fail;
18113  }
18114  plgcompression(arg1);
18115  _outv = octave_value();
18116  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18117  if (SWIG_IsTmpObj(res1)) {
18118  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18119  } else {
18120  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18121  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18122  }
18123  return _out;
18124 fail:
18125  return octave_value_list();
18126 }
18127 
18128 
18130  char *arg1 = (char *) 0 ;
18131  char local_string1[80] ;
18132  size_t local_string_length1 ;
18133  charMatrix local_charMatrix1 ;
18134  octave_value_list retval1 ;
18135  octave_value_list _out;
18136  octave_value_list *_outp=&_out;
18137  octave_value _outv;
18138 
18139  {
18140  arg1 = local_string1;
18141  }
18142  if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
18143  SWIG_fail;
18144  }
18145  plgdev(arg1);
18146  _outv = octave_value();
18147  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18148  {
18149  local_string_length1 = strlen( local_string1 );
18150  local_charMatrix1 = charMatrix( 1, local_string_length1 );
18151  local_charMatrix1.insert( local_string1, 0, 0 );
18152  retval1( 0 ) = octave_value( local_charMatrix1 );
18153  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18154  }
18155  return _out;
18156 fail:
18157  return octave_value_list();
18158 }
18159 
18160 
18162  PLFLT *arg1 = (PLFLT *) 0 ;
18163  PLFLT *arg2 = (PLFLT *) 0 ;
18164  PLFLT *arg3 = (PLFLT *) 0 ;
18165  PLFLT *arg4 = (PLFLT *) 0 ;
18166  PLFLT temp1 ;
18167  int res1 = SWIG_TMPOBJ ;
18168  PLFLT temp2 ;
18169  int res2 = SWIG_TMPOBJ ;
18170  PLFLT temp3 ;
18171  int res3 = SWIG_TMPOBJ ;
18172  PLFLT temp4 ;
18173  int res4 = SWIG_TMPOBJ ;
18174  octave_value_list _out;
18175  octave_value_list *_outp=&_out;
18176  octave_value _outv;
18177 
18178  arg1 = &temp1;
18179  arg2 = &temp2;
18180  arg3 = &temp3;
18181  arg4 = &temp4;
18182  if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
18183  SWIG_fail;
18184  }
18185  plgdidev(arg1,arg2,arg3,arg4);
18186  _outv = octave_value();
18187  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18188  if (SWIG_IsTmpObj(res1)) {
18189  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18190  } else {
18191  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18192  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18193  }
18194  if (SWIG_IsTmpObj(res2)) {
18195  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18196  } else {
18197  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18198  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18199  }
18200  if (SWIG_IsTmpObj(res3)) {
18201  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18202  } else {
18203  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18204  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18205  }
18206  if (SWIG_IsTmpObj(res4)) {
18207  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18208  } else {
18209  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18210  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18211  }
18212  return _out;
18213 fail:
18214  return octave_value_list();
18215 }
18216 
18217 
18219  PLFLT *arg1 = (PLFLT *) 0 ;
18220  PLFLT temp1 ;
18221  int res1 = SWIG_TMPOBJ ;
18222  octave_value_list _out;
18223  octave_value_list *_outp=&_out;
18224  octave_value _outv;
18225 
18226  arg1 = &temp1;
18227  if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
18228  SWIG_fail;
18229  }
18230  plgdiori(arg1);
18231  _outv = octave_value();
18232  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18233  if (SWIG_IsTmpObj(res1)) {
18234  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18235  } else {
18236  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18237  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18238  }
18239  return _out;
18240 fail:
18241  return octave_value_list();
18242 }
18243 
18244 
18246  PLFLT *arg1 = (PLFLT *) 0 ;
18247  PLFLT *arg2 = (PLFLT *) 0 ;
18248  PLFLT *arg3 = (PLFLT *) 0 ;
18249  PLFLT *arg4 = (PLFLT *) 0 ;
18250  PLFLT temp1 ;
18251  int res1 = SWIG_TMPOBJ ;
18252  PLFLT temp2 ;
18253  int res2 = SWIG_TMPOBJ ;
18254  PLFLT temp3 ;
18255  int res3 = SWIG_TMPOBJ ;
18256  PLFLT temp4 ;
18257  int res4 = SWIG_TMPOBJ ;
18258  octave_value_list _out;
18259  octave_value_list *_outp=&_out;
18260  octave_value _outv;
18261 
18262  arg1 = &temp1;
18263  arg2 = &temp2;
18264  arg3 = &temp3;
18265  arg4 = &temp4;
18266  if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
18267  SWIG_fail;
18268  }
18269  plgdiplt(arg1,arg2,arg3,arg4);
18270  _outv = octave_value();
18271  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18272  if (SWIG_IsTmpObj(res1)) {
18273  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18274  } else {
18275  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18276  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18277  }
18278  if (SWIG_IsTmpObj(res2)) {
18279  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18280  } else {
18281  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18282  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18283  }
18284  if (SWIG_IsTmpObj(res3)) {
18285  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18286  } else {
18287  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18288  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18289  }
18290  if (SWIG_IsTmpObj(res4)) {
18291  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18292  } else {
18293  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18294  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18295  }
18296  return _out;
18297 fail:
18298  return octave_value_list();
18299 }
18300 
18301 
18303  PLINT *arg1 = (PLINT *) 0 ;
18304  PLINT *arg2 = (PLINT *) 0 ;
18305  PLINT *arg3 = (PLINT *) 0 ;
18306  PLINT temp1 ;
18307  int res1 = SWIG_TMPOBJ ;
18308  PLINT temp2 ;
18309  int res2 = SWIG_TMPOBJ ;
18310  PLINT temp3 ;
18311  int res3 = SWIG_TMPOBJ ;
18312  octave_value_list _out;
18313  octave_value_list *_outp=&_out;
18314  octave_value _outv;
18315 
18316  arg1 = &temp1;
18317  arg2 = &temp2;
18318  arg3 = &temp3;
18319  if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
18320  SWIG_fail;
18321  }
18322  plgfam(arg1,arg2,arg3);
18323  _outv = octave_value();
18324  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18325  if (SWIG_IsTmpObj(res1)) {
18326  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18327  } else {
18328  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18329  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18330  }
18331  if (SWIG_IsTmpObj(res2)) {
18332  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18333  } else {
18334  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18335  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18336  }
18337  if (SWIG_IsTmpObj(res3)) {
18338  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18339  } else {
18340  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18341  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18342  }
18343  return _out;
18344 fail:
18345  return octave_value_list();
18346 }
18347 
18348 
18350  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
18351  PLUNICODE temp1 ;
18352  int res1 = SWIG_TMPOBJ ;
18353  octave_value_list _out;
18354  octave_value_list *_outp=&_out;
18355  octave_value _outv;
18356 
18357  arg1 = &temp1;
18358  if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
18359  SWIG_fail;
18360  }
18361  plgfci(arg1);
18362  _outv = octave_value();
18363  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18364  if (SWIG_IsTmpObj(res1)) {
18365  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
18366  } else {
18367  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18368  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
18369  }
18370  return _out;
18371 fail:
18372  return octave_value_list();
18373 }
18374 
18375 
18377  char *arg1 = (char *) 0 ;
18378  char local_string1[80] ;
18379  size_t local_string_length1 ;
18380  charMatrix local_charMatrix1 ;
18381  octave_value_list retval1 ;
18382  octave_value_list _out;
18383  octave_value_list *_outp=&_out;
18384  octave_value _outv;
18385 
18386  {
18387  arg1 = local_string1;
18388  }
18389  if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
18390  SWIG_fail;
18391  }
18392  plgfnam(arg1);
18393  _outv = octave_value();
18394  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18395  {
18396  local_string_length1 = strlen( local_string1 );
18397  local_charMatrix1 = charMatrix( 1, local_string_length1 );
18398  local_charMatrix1.insert( local_string1, 0, 0 );
18399  retval1( 0 ) = octave_value( local_charMatrix1 );
18400  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18401  }
18402  return _out;
18403 fail:
18404  return octave_value_list();
18405 }
18406 
18407 
18409  PLINT *arg1 = (PLINT *) 0 ;
18410  PLINT *arg2 = (PLINT *) 0 ;
18411  PLINT *arg3 = (PLINT *) 0 ;
18412  PLINT temp1 ;
18413  int res1 = SWIG_TMPOBJ ;
18414  PLINT temp2 ;
18415  int res2 = SWIG_TMPOBJ ;
18416  PLINT temp3 ;
18417  int res3 = SWIG_TMPOBJ ;
18418  octave_value_list _out;
18419  octave_value_list *_outp=&_out;
18420  octave_value _outv;
18421 
18422  arg1 = &temp1;
18423  arg2 = &temp2;
18424  arg3 = &temp3;
18425  if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
18426  SWIG_fail;
18427  }
18428  plgfont(arg1,arg2,arg3);
18429  _outv = octave_value();
18430  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18431  if (SWIG_IsTmpObj(res1)) {
18432  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18433  } else {
18434  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18435  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18436  }
18437  if (SWIG_IsTmpObj(res2)) {
18438  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18439  } else {
18440  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18441  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18442  }
18443  if (SWIG_IsTmpObj(res3)) {
18444  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18445  } else {
18446  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18447  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18448  }
18449  return _out;
18450 fail:
18451  return octave_value_list();
18452 }
18453 
18454 
18456  PLINT *arg1 = (PLINT *) 0 ;
18457  PLINT temp1 ;
18458  int res1 = SWIG_TMPOBJ ;
18459  octave_value_list _out;
18460  octave_value_list *_outp=&_out;
18461  octave_value _outv;
18462 
18463  arg1 = &temp1;
18464  if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
18465  SWIG_fail;
18466  }
18467  plglevel(arg1);
18468  _outv = octave_value();
18469  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18470  if (SWIG_IsTmpObj(res1)) {
18471  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18472  } else {
18473  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18474  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18475  }
18476  return _out;
18477 fail:
18478  return octave_value_list();
18479 }
18480 
18481 
18483  PLFLT *arg1 = (PLFLT *) 0 ;
18484  PLFLT *arg2 = (PLFLT *) 0 ;
18485  PLINT *arg3 = (PLINT *) 0 ;
18486  PLINT *arg4 = (PLINT *) 0 ;
18487  PLINT *arg5 = (PLINT *) 0 ;
18488  PLINT *arg6 = (PLINT *) 0 ;
18489  PLFLT temp1 ;
18490  int res1 = SWIG_TMPOBJ ;
18491  PLFLT temp2 ;
18492  int res2 = SWIG_TMPOBJ ;
18493  PLINT temp3 ;
18494  int res3 = SWIG_TMPOBJ ;
18495  PLINT temp4 ;
18496  int res4 = SWIG_TMPOBJ ;
18497  PLINT temp5 ;
18498  int res5 = SWIG_TMPOBJ ;
18499  PLINT temp6 ;
18500  int res6 = SWIG_TMPOBJ ;
18501  octave_value_list _out;
18502  octave_value_list *_outp=&_out;
18503  octave_value _outv;
18504 
18505  arg1 = &temp1;
18506  arg2 = &temp2;
18507  arg3 = &temp3;
18508  arg4 = &temp4;
18509  arg5 = &temp5;
18510  arg6 = &temp6;
18511  if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
18512  SWIG_fail;
18513  }
18514  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
18515  _outv = octave_value();
18516  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18517  if (SWIG_IsTmpObj(res1)) {
18518  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18519  } else {
18520  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18521  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18522  }
18523  if (SWIG_IsTmpObj(res2)) {
18524  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18525  } else {
18526  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18527  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18528  }
18529  if (SWIG_IsTmpObj(res3)) {
18530  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18531  } else {
18532  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18533  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18534  }
18535  if (SWIG_IsTmpObj(res4)) {
18536  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18537  } else {
18538  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18539  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18540  }
18541  if (SWIG_IsTmpObj(res5)) {
18542  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
18543  } else {
18544  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18545  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
18546  }
18547  if (SWIG_IsTmpObj(res6)) {
18548  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
18549  } else {
18550  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18551  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
18552  }
18553  return _out;
18554 fail:
18555  return octave_value_list();
18556 }
18557 
18558 
18560  octave_value_list _out;
18561  octave_value_list *_outp=&_out;
18562  octave_value _outv;
18563 
18564  if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
18565  SWIG_fail;
18566  }
18567  plgra();
18568  _outv = octave_value();
18569  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18570  return _out;
18571 fail:
18572  return octave_value_list();
18573 }
18574 
18575 
18577  PLFLT *arg1 = (PLFLT *) 0 ;
18578  PLFLT *arg2 = (PLFLT *) 0 ;
18579  PLFLT *arg3 = (PLFLT *) 0 ;
18580  PLFLT *arg4 = (PLFLT *) 0 ;
18581  PLFLT temp1 ;
18582  int res1 = SWIG_TMPOBJ ;
18583  PLFLT temp2 ;
18584  int res2 = SWIG_TMPOBJ ;
18585  PLFLT temp3 ;
18586  int res3 = SWIG_TMPOBJ ;
18587  PLFLT temp4 ;
18588  int res4 = SWIG_TMPOBJ ;
18589  octave_value_list _out;
18590  octave_value_list *_outp=&_out;
18591  octave_value _outv;
18592 
18593  arg1 = &temp1;
18594  arg2 = &temp2;
18595  arg3 = &temp3;
18596  arg4 = &temp4;
18597  if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
18598  SWIG_fail;
18599  }
18600  plgspa(arg1,arg2,arg3,arg4);
18601  _outv = octave_value();
18602  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18603  if (SWIG_IsTmpObj(res1)) {
18604  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18605  } else {
18606  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18607  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18608  }
18609  if (SWIG_IsTmpObj(res2)) {
18610  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18611  } else {
18612  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18613  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18614  }
18615  if (SWIG_IsTmpObj(res3)) {
18616  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18617  } else {
18618  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18619  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18620  }
18621  if (SWIG_IsTmpObj(res4)) {
18622  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18623  } else {
18624  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18625  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18626  }
18627  return _out;
18628 fail:
18629  return octave_value_list();
18630 }
18631 
18632 
18634  PLINT *arg1 = (PLINT *) 0 ;
18635  PLINT temp1 ;
18636  int res1 = SWIG_TMPOBJ ;
18637  octave_value_list _out;
18638  octave_value_list *_outp=&_out;
18639  octave_value _outv;
18640 
18641  arg1 = &temp1;
18642  if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
18643  SWIG_fail;
18644  }
18645  plgstrm(arg1);
18646  _outv = octave_value();
18647  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18648  if (SWIG_IsTmpObj(res1)) {
18649  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18650  } else {
18651  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18652  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18653  }
18654  return _out;
18655 fail:
18656  return octave_value_list();
18657 }
18658 
18659 
18661  char *arg1 = (char *) 0 ;
18662  char local_string1[80] ;
18663  size_t local_string_length1 ;
18664  charMatrix local_charMatrix1 ;
18665  octave_value_list retval1 ;
18666  octave_value_list _out;
18667  octave_value_list *_outp=&_out;
18668  octave_value _outv;
18669 
18670  {
18671  arg1 = local_string1;
18672  }
18673  if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
18674  SWIG_fail;
18675  }
18676  plgver(arg1);
18677  _outv = octave_value();
18678  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18679  {
18680  local_string_length1 = strlen( local_string1 );
18681  local_charMatrix1 = charMatrix( 1, local_string_length1 );
18682  local_charMatrix1.insert( local_string1, 0, 0 );
18683  retval1( 0 ) = octave_value( local_charMatrix1 );
18684  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18685  }
18686  return _out;
18687 fail:
18688  return octave_value_list();
18689 }
18690 
18691 
18693  PLFLT *arg1 = (PLFLT *) 0 ;
18694  PLFLT *arg2 = (PLFLT *) 0 ;
18695  PLFLT *arg3 = (PLFLT *) 0 ;
18696  PLFLT *arg4 = (PLFLT *) 0 ;
18697  PLFLT temp1 ;
18698  int res1 = SWIG_TMPOBJ ;
18699  PLFLT temp2 ;
18700  int res2 = SWIG_TMPOBJ ;
18701  PLFLT temp3 ;
18702  int res3 = SWIG_TMPOBJ ;
18703  PLFLT temp4 ;
18704  int res4 = SWIG_TMPOBJ ;
18705  octave_value_list _out;
18706  octave_value_list *_outp=&_out;
18707  octave_value _outv;
18708 
18709  arg1 = &temp1;
18710  arg2 = &temp2;
18711  arg3 = &temp3;
18712  arg4 = &temp4;
18713  if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
18714  SWIG_fail;
18715  }
18716  plgvpd(arg1,arg2,arg3,arg4);
18717  _outv = octave_value();
18718  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18719  if (SWIG_IsTmpObj(res1)) {
18720  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18721  } else {
18722  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18723  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18724  }
18725  if (SWIG_IsTmpObj(res2)) {
18726  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18727  } else {
18728  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18729  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18730  }
18731  if (SWIG_IsTmpObj(res3)) {
18732  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18733  } else {
18734  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18735  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18736  }
18737  if (SWIG_IsTmpObj(res4)) {
18738  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18739  } else {
18740  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18741  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18742  }
18743  return _out;
18744 fail:
18745  return octave_value_list();
18746 }
18747 
18748 
18750  PLFLT *arg1 = (PLFLT *) 0 ;
18751  PLFLT *arg2 = (PLFLT *) 0 ;
18752  PLFLT *arg3 = (PLFLT *) 0 ;
18753  PLFLT *arg4 = (PLFLT *) 0 ;
18754  PLFLT temp1 ;
18755  int res1 = SWIG_TMPOBJ ;
18756  PLFLT temp2 ;
18757  int res2 = SWIG_TMPOBJ ;
18758  PLFLT temp3 ;
18759  int res3 = SWIG_TMPOBJ ;
18760  PLFLT temp4 ;
18761  int res4 = SWIG_TMPOBJ ;
18762  octave_value_list _out;
18763  octave_value_list *_outp=&_out;
18764  octave_value _outv;
18765 
18766  arg1 = &temp1;
18767  arg2 = &temp2;
18768  arg3 = &temp3;
18769  arg4 = &temp4;
18770  if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
18771  SWIG_fail;
18772  }
18773  plgvpw(arg1,arg2,arg3,arg4);
18774  _outv = octave_value();
18775  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18776  if (SWIG_IsTmpObj(res1)) {
18777  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18778  } else {
18779  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18780  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18781  }
18782  if (SWIG_IsTmpObj(res2)) {
18783  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18784  } else {
18785  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18786  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18787  }
18788  if (SWIG_IsTmpObj(res3)) {
18789  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18790  } else {
18791  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18792  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18793  }
18794  if (SWIG_IsTmpObj(res4)) {
18795  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18796  } else {
18797  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18798  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18799  }
18800  return _out;
18801 fail:
18802  return octave_value_list();
18803 }
18804 
18805 
18807  PLINT *arg1 = (PLINT *) 0 ;
18808  PLINT *arg2 = (PLINT *) 0 ;
18809  PLINT temp1 ;
18810  int res1 = SWIG_TMPOBJ ;
18811  PLINT temp2 ;
18812  int res2 = SWIG_TMPOBJ ;
18813  octave_value_list _out;
18814  octave_value_list *_outp=&_out;
18815  octave_value _outv;
18816 
18817  arg1 = &temp1;
18818  arg2 = &temp2;
18819  if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
18820  SWIG_fail;
18821  }
18822  plgxax(arg1,arg2);
18823  _outv = octave_value();
18824  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18825  if (SWIG_IsTmpObj(res1)) {
18826  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18827  } else {
18828  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18829  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18830  }
18831  if (SWIG_IsTmpObj(res2)) {
18832  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18833  } else {
18834  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18835  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18836  }
18837  return _out;
18838 fail:
18839  return octave_value_list();
18840 }
18841 
18842 
18844  PLINT *arg1 = (PLINT *) 0 ;
18845  PLINT *arg2 = (PLINT *) 0 ;
18846  PLINT temp1 ;
18847  int res1 = SWIG_TMPOBJ ;
18848  PLINT temp2 ;
18849  int res2 = SWIG_TMPOBJ ;
18850  octave_value_list _out;
18851  octave_value_list *_outp=&_out;
18852  octave_value _outv;
18853 
18854  arg1 = &temp1;
18855  arg2 = &temp2;
18856  if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
18857  SWIG_fail;
18858  }
18859  plgyax(arg1,arg2);
18860  _outv = octave_value();
18861  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18862  if (SWIG_IsTmpObj(res1)) {
18863  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18864  } else {
18865  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18866  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18867  }
18868  if (SWIG_IsTmpObj(res2)) {
18869  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18870  } else {
18871  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18872  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18873  }
18874  return _out;
18875 fail:
18876  return octave_value_list();
18877 }
18878 
18879 
18881  PLINT *arg1 = (PLINT *) 0 ;
18882  PLINT *arg2 = (PLINT *) 0 ;
18883  PLINT temp1 ;
18884  int res1 = SWIG_TMPOBJ ;
18885  PLINT temp2 ;
18886  int res2 = SWIG_TMPOBJ ;
18887  octave_value_list _out;
18888  octave_value_list *_outp=&_out;
18889  octave_value _outv;
18890 
18891  arg1 = &temp1;
18892  arg2 = &temp2;
18893  if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
18894  SWIG_fail;
18895  }
18896  plgzax(arg1,arg2);
18897  _outv = octave_value();
18898  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18899  if (SWIG_IsTmpObj(res1)) {
18900  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18901  } else {
18902  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18903  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18904  }
18905  if (SWIG_IsTmpObj(res2)) {
18906  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18907  } else {
18908  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18909  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18910  }
18911  return _out;
18912 fail:
18913  return octave_value_list();
18914 }
18915 
18916 
18918  PLINT arg1 ;
18919  PLFLT *arg2 = (PLFLT *) 0 ;
18920  PLFLT arg3 ;
18921  PLFLT arg4 ;
18922  PLINT arg5 ;
18923  PLINT arg6 ;
18924  Matrix temp1 ;
18925  double val3 ;
18926  int ecode3 = 0 ;
18927  double val4 ;
18928  int ecode4 = 0 ;
18929  int val5 ;
18930  int ecode5 = 0 ;
18931  int val6 ;
18932  int ecode6 = 0 ;
18933  octave_value_list _out;
18934  octave_value_list *_outp=&_out;
18935  octave_value _outv;
18936 
18937  if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
18938  SWIG_fail;
18939  }
18940  {
18941  if ( _n_dims( args(0) ) > 1 )
18942  {
18943  error( "argument must be a scalar or vector" ); SWIG_fail;
18944  }
18945  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18946  temp1 = args(0).matrix_value();
18947  arg2 = &temp1( 0, 0 );
18948  }
18949  ecode3 = SWIG_AsVal_double(args(1), &val3);
18950  if (!SWIG_IsOK(ecode3)) {
18951  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
18952  }
18953  arg3 = static_cast< PLFLT >(val3);
18954  ecode4 = SWIG_AsVal_double(args(2), &val4);
18955  if (!SWIG_IsOK(ecode4)) {
18956  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
18957  }
18958  arg4 = static_cast< PLFLT >(val4);
18959  ecode5 = SWIG_AsVal_int(args(3), &val5);
18960  if (!SWIG_IsOK(ecode5)) {
18961  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
18962  }
18963  arg5 = static_cast< PLINT >(val5);
18964  ecode6 = SWIG_AsVal_int(args(4), &val6);
18965  if (!SWIG_IsOK(ecode6)) {
18966  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
18967  }
18968  arg6 = static_cast< PLINT >(val6);
18969  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
18970  _outv = octave_value();
18971  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18972  {
18973 
18974  }
18975  return _out;
18976 fail:
18977  {
18978 
18979  }
18980  return octave_value_list();
18981 }
18982 
18983 
18985  PLFLT arg1 ;
18986  PLFLT arg2 ;
18987  PLFLT arg3 ;
18988  PLFLT *arg4 = (PLFLT *) 0 ;
18989  PLFLT *arg5 = (PLFLT *) 0 ;
18990  PLFLT *arg6 = (PLFLT *) 0 ;
18991  double val1 ;
18992  int ecode1 = 0 ;
18993  double val2 ;
18994  int ecode2 = 0 ;
18995  double val3 ;
18996  int ecode3 = 0 ;
18997  PLFLT temp4 ;
18998  int res4 = SWIG_TMPOBJ ;
18999  PLFLT temp5 ;
19000  int res5 = SWIG_TMPOBJ ;
19001  PLFLT temp6 ;
19002  int res6 = SWIG_TMPOBJ ;
19003  octave_value_list _out;
19004  octave_value_list *_outp=&_out;
19005  octave_value _outv;
19006 
19007  arg4 = &temp4;
19008  arg5 = &temp5;
19009  arg6 = &temp6;
19010  if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
19011  SWIG_fail;
19012  }
19013  ecode1 = SWIG_AsVal_double(args(0), &val1);
19014  if (!SWIG_IsOK(ecode1)) {
19015  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
19016  }
19017  arg1 = static_cast< PLFLT >(val1);
19018  ecode2 = SWIG_AsVal_double(args(1), &val2);
19019  if (!SWIG_IsOK(ecode2)) {
19020  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
19021  }
19022  arg2 = static_cast< PLFLT >(val2);
19023  ecode3 = SWIG_AsVal_double(args(2), &val3);
19024  if (!SWIG_IsOK(ecode3)) {
19025  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
19026  }
19027  arg3 = static_cast< PLFLT >(val3);
19028  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
19029  _outv = octave_value();
19030  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19031  if (SWIG_IsTmpObj(res4)) {
19032  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19033  } else {
19034  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19035  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19036  }
19037  if (SWIG_IsTmpObj(res5)) {
19038  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19039  } else {
19040  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19041  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19042  }
19043  if (SWIG_IsTmpObj(res6)) {
19044  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
19045  } else {
19046  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19047  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
19048  }
19049  return _out;
19050 fail:
19051  return octave_value_list();
19052 }
19053 
19054 
19056  octave_value_list _out;
19057  octave_value_list *_outp=&_out;
19058  octave_value _outv;
19059 
19060  if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
19061  SWIG_fail;
19062  }
19063  plinit();
19064  _outv = octave_value();
19065  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19066  return _out;
19067 fail:
19068  return octave_value_list();
19069 }
19070 
19071 
19073  PLFLT arg1 ;
19074  PLFLT arg2 ;
19075  PLFLT arg3 ;
19076  PLFLT arg4 ;
19077  double val1 ;
19078  int ecode1 = 0 ;
19079  double val2 ;
19080  int ecode2 = 0 ;
19081  double val3 ;
19082  int ecode3 = 0 ;
19083  double val4 ;
19084  int ecode4 = 0 ;
19085  octave_value_list _out;
19086  octave_value_list *_outp=&_out;
19087  octave_value _outv;
19088 
19089  if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
19090  SWIG_fail;
19091  }
19092  ecode1 = SWIG_AsVal_double(args(0), &val1);
19093  if (!SWIG_IsOK(ecode1)) {
19094  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
19095  }
19096  arg1 = static_cast< PLFLT >(val1);
19097  ecode2 = SWIG_AsVal_double(args(1), &val2);
19098  if (!SWIG_IsOK(ecode2)) {
19099  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
19100  }
19101  arg2 = static_cast< PLFLT >(val2);
19102  ecode3 = SWIG_AsVal_double(args(2), &val3);
19103  if (!SWIG_IsOK(ecode3)) {
19104  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
19105  }
19106  arg3 = static_cast< PLFLT >(val3);
19107  ecode4 = SWIG_AsVal_double(args(3), &val4);
19108  if (!SWIG_IsOK(ecode4)) {
19109  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
19110  }
19111  arg4 = static_cast< PLFLT >(val4);
19112  pljoin(arg1,arg2,arg3,arg4);
19113  _outv = octave_value();
19114  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19115  return _out;
19116 fail:
19117  return octave_value_list();
19118 }
19119 
19120 
19122  char *arg1 = (char *) 0 ;
19123  char *arg2 = (char *) 0 ;
19124  char *arg3 = (char *) 0 ;
19125  int res1 ;
19126  char *buf1 = 0 ;
19127  int alloc1 = 0 ;
19128  int res2 ;
19129  char *buf2 = 0 ;
19130  int alloc2 = 0 ;
19131  int res3 ;
19132  char *buf3 = 0 ;
19133  int alloc3 = 0 ;
19134  octave_value_list _out;
19135  octave_value_list *_outp=&_out;
19136  octave_value _outv;
19137 
19138  if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
19139  SWIG_fail;
19140  }
19141  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19142  if (!SWIG_IsOK(res1)) {
19143  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
19144  }
19145  arg1 = reinterpret_cast< char * >(buf1);
19146  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
19147  if (!SWIG_IsOK(res2)) {
19148  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
19149  }
19150  arg2 = reinterpret_cast< char * >(buf2);
19151  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
19152  if (!SWIG_IsOK(res3)) {
19153  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
19154  }
19155  arg3 = reinterpret_cast< char * >(buf3);
19156  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
19157  _outv = octave_value();
19158  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19159  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19160  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19161  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19162  return _out;
19163 fail:
19164  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19165  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19166  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19167  return octave_value_list();
19168 }
19169 
19170 
19172  PLFLT *arg1 = (PLFLT *) 0 ;
19173  PLFLT *arg2 = (PLFLT *) 0 ;
19174  PLINT arg3 ;
19175  PLINT arg4 ;
19176  PLFLT arg5 ;
19177  PLFLT arg6 ;
19178  PLFLT arg7 ;
19179  PLINT arg8 ;
19180  PLINT arg9 ;
19181  PLINT arg10 ;
19182  PLINT arg11 ;
19183  PLINT arg12 ;
19184  PLINT arg13 ;
19185  PLINT *arg14 = (PLINT *) 0 ;
19186  PLFLT arg15 ;
19187  PLFLT arg16 ;
19188  PLFLT arg17 ;
19189  PLFLT arg18 ;
19190  PLINT *arg19 = (PLINT *) 0 ;
19191  char **arg20 = (char **) 0 ;
19192  PLINT *arg21 = (PLINT *) 0 ;
19193  PLINT *arg22 = (PLINT *) 0 ;
19194  PLFLT *arg23 = (PLFLT *) 0 ;
19195  PLFLT *arg24 = (PLFLT *) 0 ;
19196  PLINT *arg25 = (PLINT *) 0 ;
19197  PLINT *arg26 = (PLINT *) 0 ;
19198  PLFLT *arg27 = (PLFLT *) 0 ;
19199  PLINT *arg28 = (PLINT *) 0 ;
19200  PLFLT *arg29 = (PLFLT *) 0 ;
19201  PLINT *arg30 = (PLINT *) 0 ;
19202  char **arg31 = (char **) 0 ;
19203  PLFLT temp1 ;
19204  int res1 = SWIG_TMPOBJ ;
19205  PLFLT temp2 ;
19206  int res2 = SWIG_TMPOBJ ;
19207  int val3 ;
19208  int ecode3 = 0 ;
19209  int val4 ;
19210  int ecode4 = 0 ;
19211  double val5 ;
19212  int ecode5 = 0 ;
19213  double val6 ;
19214  int ecode6 = 0 ;
19215  double val7 ;
19216  int ecode7 = 0 ;
19217  int val8 ;
19218  int ecode8 = 0 ;
19219  int val9 ;
19220  int ecode9 = 0 ;
19221  int val10 ;
19222  int ecode10 = 0 ;
19223  int val11 ;
19224  int ecode11 = 0 ;
19225  int val12 ;
19226  int ecode12 = 0 ;
19227  Matrix temp13 ;
19228  double val15 ;
19229  int ecode15 = 0 ;
19230  double val16 ;
19231  int ecode16 = 0 ;
19232  double val17 ;
19233  int ecode17 = 0 ;
19234  double val18 ;
19235  int ecode18 = 0 ;
19236  Matrix temp19 ;
19237  Matrix temp21 ;
19238  Matrix temp22 ;
19239  Matrix temp23 ;
19240  Matrix temp24 ;
19241  Matrix temp25 ;
19242  Matrix temp26 ;
19243  Matrix temp27 ;
19244  Matrix temp28 ;
19245  Matrix temp29 ;
19246  Matrix temp30 ;
19247  octave_value_list _out;
19248  octave_value_list *_outp=&_out;
19249  octave_value _outv;
19250 
19251  arg1 = &temp1;
19252  arg2 = &temp2;
19253  if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
19254  SWIG_fail;
19255  }
19256  ecode3 = SWIG_AsVal_int(args(0), &val3);
19257  if (!SWIG_IsOK(ecode3)) {
19258  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
19259  }
19260  arg3 = static_cast< PLINT >(val3);
19261  ecode4 = SWIG_AsVal_int(args(1), &val4);
19262  if (!SWIG_IsOK(ecode4)) {
19263  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
19264  }
19265  arg4 = static_cast< PLINT >(val4);
19266  ecode5 = SWIG_AsVal_double(args(2), &val5);
19267  if (!SWIG_IsOK(ecode5)) {
19268  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
19269  }
19270  arg5 = static_cast< PLFLT >(val5);
19271  ecode6 = SWIG_AsVal_double(args(3), &val6);
19272  if (!SWIG_IsOK(ecode6)) {
19273  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
19274  }
19275  arg6 = static_cast< PLFLT >(val6);
19276  ecode7 = SWIG_AsVal_double(args(4), &val7);
19277  if (!SWIG_IsOK(ecode7)) {
19278  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
19279  }
19280  arg7 = static_cast< PLFLT >(val7);
19281  ecode8 = SWIG_AsVal_int(args(5), &val8);
19282  if (!SWIG_IsOK(ecode8)) {
19283  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
19284  }
19285  arg8 = static_cast< PLINT >(val8);
19286  ecode9 = SWIG_AsVal_int(args(6), &val9);
19287  if (!SWIG_IsOK(ecode9)) {
19288  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
19289  }
19290  arg9 = static_cast< PLINT >(val9);
19291  ecode10 = SWIG_AsVal_int(args(7), &val10);
19292  if (!SWIG_IsOK(ecode10)) {
19293  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
19294  }
19295  arg10 = static_cast< PLINT >(val10);
19296  ecode11 = SWIG_AsVal_int(args(8), &val11);
19297  if (!SWIG_IsOK(ecode11)) {
19298  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
19299  }
19300  arg11 = static_cast< PLINT >(val11);
19301  ecode12 = SWIG_AsVal_int(args(9), &val12);
19302  if (!SWIG_IsOK(ecode12)) {
19303  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
19304  }
19305  arg12 = static_cast< PLINT >(val12);
19306  {
19307  if ( _n_dims( args(10) ) > 1 )
19308  {
19309  error( "argument must be a scalar or vector" ); SWIG_fail;
19310  }
19311  arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
19312  arg14 = new PLINT[Alen];
19313  temp13 = args(10).matrix_value();
19314  _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
19315  }
19316  ecode15 = SWIG_AsVal_double(args(11), &val15);
19317  if (!SWIG_IsOK(ecode15)) {
19318  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
19319  }
19320  arg15 = static_cast< PLFLT >(val15);
19321  ecode16 = SWIG_AsVal_double(args(12), &val16);
19322  if (!SWIG_IsOK(ecode16)) {
19323  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
19324  }
19325  arg16 = static_cast< PLFLT >(val16);
19326  ecode17 = SWIG_AsVal_double(args(13), &val17);
19327  if (!SWIG_IsOK(ecode17)) {
19328  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
19329  }
19330  arg17 = static_cast< PLFLT >(val17);
19331  ecode18 = SWIG_AsVal_double(args(14), &val18);
19332  if (!SWIG_IsOK(ecode18)) {
19333  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
19334  }
19335  arg18 = static_cast< PLFLT >(val18);
19336  {
19337  if ( _n_dims( args(15) ) > 1 )
19338  {
19339  error( "argument must be a scalar or vector" ); SWIG_fail;
19340  }
19341  if ( _dim( args(15), 0 ) != Alen )
19342  {
19343  error( "argument vectors must be same length" ); SWIG_fail;
19344  }
19345  temp19 = args(15).matrix_value();
19346  arg19 = new PLINT[Alen];
19347  _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
19348  }
19349  {
19350  charMatrix temp_matrix;
19351  Cell temp_cell;
19352  char *tmp_cstring;
19353  std::string str;
19354  size_t max_length = 0, non_blank_length;
19355  int i, ifcell;
19356  if ( _n_dims( args(16) ) > 2 )
19357  {
19358  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
19359  }
19360 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19361  if ( !args(16).isempty() )
19362 #else
19363  if ( !args(16).is_empty() )
19364 #endif
19365  {
19366  if ( _dim( args(16), 0 ) != Alen )
19367  {
19368  error( "first dimension must be same length as previous vector" ); SWIG_fail;
19369  }
19370  arg20 = new char*[Alen];
19371 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19372  ifcell = args(16).iscell();
19373 #else
19374  ifcell = args(16).is_cell();
19375 #endif
19376  if ( ifcell )
19377  {
19378  temp_cell = args(16).cell_value();
19379  }
19380  else
19381  {
19382  temp_matrix = args(16).char_matrix_value();
19383  // Allow one extra space for null termination.
19384  max_length = _dim( args(16), 1 ) + 1;
19385  }
19386 
19387  for ( i = 0; i < Alen; i++ )
19388  {
19389  // Must copy string to "permanent" location because the string
19390  // location corresponding to tmp_cstring gets
19391  // overwritten for each iteration of loop.
19392  if ( ifcell )
19393  {
19394  if ( temp_cell.elem( i ).is_string() )
19395  {
19396  str = temp_cell.elem( i ).string_value();
19397  // leave room for null termination.
19398  max_length = str.size() + 1;
19399  tmp_cstring = (char *) str.c_str();
19400  }
19401  else
19402  {
19403  // Use null string if user attempts to pass a cell array
19404  // with a non-string element (likely an empty element
19405  // since that should be allowed by the PLplot interface
19406  // if that element is going to be unused).
19407  // leave room for null termination.
19408  max_length = 1;
19409  tmp_cstring = (char *) "";
19410  }
19411  }
19412  else
19413  {
19414  str = temp_matrix.row_as_string( i );
19415  tmp_cstring = (char *) str.c_str();
19416  }
19417  arg20[i] = new char[max_length];
19418  strncpy( arg20[i], tmp_cstring, max_length - 1 );
19419  arg20[i][max_length - 1] = '\0';
19420  // All the trailing blank crapola should not be needed for
19421  // string cell arrays.
19422  if ( !ifcell )
19423  {
19424  // remove trailing-blank padding that is used by the
19425  // charMatrix class to insure all strings in a given
19426  // charMatrix instance have the same length.
19427  // This transformation also removes legitimate trailing
19428  // blanks but there is nothing we can do about that
19429  // for the charMatrix class.
19430 
19431  // Look for trailing nulls first (just in case, although that
19432  // shouldn't happen if charMatrix implemented as documented)
19433  // before looking for trailing blanks.
19434  non_blank_length = max_length - 2;
19435  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
19436  {
19437  non_blank_length--;
19438  }
19439  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
19440  {
19441  non_blank_length--;
19442  }
19443  arg20[i][non_blank_length + 1] = '\0';
19444  }
19445  }
19446  }
19447  else
19448  {
19449  arg20 = NULL;
19450  }
19451  }
19452  {
19453  if ( _n_dims( args(17) ) > 1 )
19454  {
19455  error( "argument must be a scalar or vector" ); SWIG_fail;
19456  }
19457 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19458  if ( !args(17).isempty() )
19459 #else
19460  if ( !args(17).is_empty() )
19461 #endif
19462  {
19463  if ( _dim( args(17), 0 ) != Alen )
19464  {
19465  error( "argument vectors must be same length" ); SWIG_fail;
19466  }
19467  temp21 = args(17).matrix_value();
19468  arg21 = new PLINT[Alen];
19469  _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
19470  }
19471  else
19472  {
19473  arg21 = NULL;
19474  }
19475  }
19476  {
19477  if ( _n_dims( args(18) ) > 1 )
19478  {
19479  error( "argument must be a scalar or vector" ); SWIG_fail;
19480  }
19481 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19482  if ( !args(18).isempty() )
19483 #else
19484  if ( !args(18).is_empty() )
19485 #endif
19486  {
19487  if ( _dim( args(18), 0 ) != Alen )
19488  {
19489  error( "argument vectors must be same length" ); SWIG_fail;
19490  }
19491  temp22 = args(18).matrix_value();
19492  arg22 = new PLINT[Alen];
19493  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
19494  }
19495  else
19496  {
19497  arg22 = NULL;
19498  }
19499  }
19500  {
19501  if ( _n_dims( args(19) ) > 1 )
19502  {
19503  error( "argument must be a scalar or vector" ); SWIG_fail;
19504  }
19505 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19506  if ( !args(19).isempty() )
19507 #else
19508  if ( !args(19).is_empty() )
19509 #endif
19510  {
19511  if ( _dim( args(19), 0 ) != Alen )
19512  {
19513  error( "argument vectors must be same length" ); SWIG_fail;
19514  }
19515  temp23 = args(19).matrix_value();
19516  arg23 = &temp23( 0, 0 );
19517  }
19518  else
19519  {
19520  arg23 = NULL;
19521  }
19522  }
19523  {
19524  if ( _n_dims( args(20) ) > 1 )
19525  {
19526  error( "argument must be a scalar or vector" ); SWIG_fail;
19527  }
19528 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19529  if ( !args(20).isempty() )
19530 #else
19531  if ( !args(20).is_empty() )
19532 #endif
19533  {
19534  if ( _dim( args(20), 0 ) != Alen )
19535  {
19536  error( "argument vectors must be same length" ); SWIG_fail;
19537  }
19538  temp24 = args(20).matrix_value();
19539  arg24 = &temp24( 0, 0 );
19540  }
19541  else
19542  {
19543  arg24 = NULL;
19544  }
19545  }
19546  {
19547  if ( _n_dims( args(21) ) > 1 )
19548  {
19549  error( "argument must be a scalar or vector" ); SWIG_fail;
19550  }
19551 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19552  if ( !args(21).isempty() )
19553 #else
19554  if ( !args(21).is_empty() )
19555 #endif
19556  {
19557  if ( _dim( args(21), 0 ) != Alen )
19558  {
19559  error( "argument vectors must be same length" ); SWIG_fail;
19560  }
19561  temp25 = args(21).matrix_value();
19562  arg25 = new PLINT[Alen];
19563  _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
19564  }
19565  else
19566  {
19567  arg25 = NULL;
19568  }
19569  }
19570  {
19571  if ( _n_dims( args(22) ) > 1 )
19572  {
19573  error( "argument must be a scalar or vector" ); SWIG_fail;
19574  }
19575 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19576  if ( !args(22).isempty() )
19577 #else
19578  if ( !args(22).is_empty() )
19579 #endif
19580  {
19581  if ( _dim( args(22), 0 ) != Alen )
19582  {
19583  error( "argument vectors must be same length" ); SWIG_fail;
19584  }
19585  temp26 = args(22).matrix_value();
19586  arg26 = new PLINT[Alen];
19587  _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
19588  }
19589  else
19590  {
19591  arg26 = NULL;
19592  }
19593  }
19594  {
19595  if ( _n_dims( args(23) ) > 1 )
19596  {
19597  error( "argument must be a scalar or vector" ); SWIG_fail;
19598  }
19599 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19600  if ( !args(23).isempty() )
19601 #else
19602  if ( !args(23).is_empty() )
19603 #endif
19604  {
19605  if ( _dim( args(23), 0 ) != Alen )
19606  {
19607  error( "argument vectors must be same length" ); SWIG_fail;
19608  }
19609  temp27 = args(23).matrix_value();
19610  arg27 = &temp27( 0, 0 );
19611  }
19612  else
19613  {
19614  arg27 = NULL;
19615  }
19616  }
19617  {
19618  if ( _n_dims( args(24) ) > 1 )
19619  {
19620  error( "argument must be a scalar or vector" ); SWIG_fail;
19621  }
19622 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19623  if ( !args(24).isempty() )
19624 #else
19625  if ( !args(24).is_empty() )
19626 #endif
19627  {
19628  if ( _dim( args(24), 0 ) != Alen )
19629  {
19630  error( "argument vectors must be same length" ); SWIG_fail;
19631  }
19632  temp28 = args(24).matrix_value();
19633  arg28 = new PLINT[Alen];
19634  _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
19635  }
19636  else
19637  {
19638  arg28 = NULL;
19639  }
19640  }
19641  {
19642  if ( _n_dims( args(25) ) > 1 )
19643  {
19644  error( "argument must be a scalar or vector" ); SWIG_fail;
19645  }
19646 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19647  if ( !args(25).isempty() )
19648 #else
19649  if ( !args(25).is_empty() )
19650 #endif
19651  {
19652  if ( _dim( args(25), 0 ) != Alen )
19653  {
19654  error( "argument vectors must be same length" ); SWIG_fail;
19655  }
19656  temp29 = args(25).matrix_value();
19657  arg29 = &temp29( 0, 0 );
19658  }
19659  else
19660  {
19661  arg29 = NULL;
19662  }
19663  }
19664  {
19665  if ( _n_dims( args(26) ) > 1 )
19666  {
19667  error( "argument must be a scalar or vector" ); SWIG_fail;
19668  }
19669 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19670  if ( !args(26).isempty() )
19671 #else
19672  if ( !args(26).is_empty() )
19673 #endif
19674  {
19675  if ( _dim( args(26), 0 ) != Alen )
19676  {
19677  error( "argument vectors must be same length" ); SWIG_fail;
19678  }
19679  temp30 = args(26).matrix_value();
19680  arg30 = new PLINT[Alen];
19681  _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
19682  }
19683  else
19684  {
19685  arg30 = NULL;
19686  }
19687  }
19688  {
19689  charMatrix temp_matrix;
19690  Cell temp_cell;
19691  char *tmp_cstring;
19692  std::string str;
19693  size_t max_length = 0, non_blank_length;
19694  int i, ifcell;
19695  if ( _n_dims( args(27) ) > 2 )
19696  {
19697  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
19698  }
19699 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19700  if ( !args(27).isempty() )
19701 #else
19702  if ( !args(27).is_empty() )
19703 #endif
19704  {
19705  if ( _dim( args(27), 0 ) != Alen )
19706  {
19707  error( "first dimension must be same length as previous vector" ); SWIG_fail;
19708  }
19709  arg31 = new char*[Alen];
19710 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19711  ifcell = args(27).iscell();
19712 #else
19713  ifcell = args(27).is_cell();
19714 #endif
19715  if ( ifcell )
19716  {
19717  temp_cell = args(27).cell_value();
19718  }
19719  else
19720  {
19721  temp_matrix = args(27).char_matrix_value();
19722  // Allow one extra space for null termination.
19723  max_length = _dim( args(27), 1 ) + 1;
19724  }
19725 
19726  for ( i = 0; i < Alen; i++ )
19727  {
19728  // Must copy string to "permanent" location because the string
19729  // location corresponding to tmp_cstring gets
19730  // overwritten for each iteration of loop.
19731  if ( ifcell )
19732  {
19733  if ( temp_cell.elem( i ).is_string() )
19734  {
19735  str = temp_cell.elem( i ).string_value();
19736  // leave room for null termination.
19737  max_length = str.size() + 1;
19738  tmp_cstring = (char *) str.c_str();
19739  }
19740  else
19741  {
19742  // Use null string if user attempts to pass a cell array
19743  // with a non-string element (likely an empty element
19744  // since that should be allowed by the PLplot interface
19745  // if that element is going to be unused).
19746  // leave room for null termination.
19747  max_length = 1;
19748  tmp_cstring = (char *) "";
19749  }
19750  }
19751  else
19752  {
19753  str = temp_matrix.row_as_string( i );
19754  tmp_cstring = (char *) str.c_str();
19755  }
19756  arg31[i] = new char[max_length];
19757  strncpy( arg31[i], tmp_cstring, max_length - 1 );
19758  arg31[i][max_length - 1] = '\0';
19759  // All the trailing blank crapola should not be needed for
19760  // string cell arrays.
19761  if ( !ifcell )
19762  {
19763  // remove trailing-blank padding that is used by the
19764  // charMatrix class to insure all strings in a given
19765  // charMatrix instance have the same length.
19766  // This transformation also removes legitimate trailing
19767  // blanks but there is nothing we can do about that
19768  // for the charMatrix class.
19769 
19770  // Look for trailing nulls first (just in case, although that
19771  // shouldn't happen if charMatrix implemented as documented)
19772  // before looking for trailing blanks.
19773  non_blank_length = max_length - 2;
19774  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
19775  {
19776  non_blank_length--;
19777  }
19778  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
19779  {
19780  non_blank_length--;
19781  }
19782  arg31[i][non_blank_length + 1] = '\0';
19783  }
19784  }
19785  }
19786  else
19787  {
19788  arg31 = NULL;
19789  }
19790  }
19791  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);
19792  _outv = octave_value();
19793  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19794  if (SWIG_IsTmpObj(res1)) {
19795  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19796  } else {
19797  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19798  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19799  }
19800  if (SWIG_IsTmpObj(res2)) {
19801  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19802  } else {
19803  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19804  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19805  }
19806  {
19807  delete [] arg14;
19808  }
19809  {
19810  delete [] arg19;
19811  }
19812  {
19813  int i;
19814  if ( arg20 != NULL )
19815  {
19816  for ( i = 0; i < Alen; i++ )
19817  {
19818  delete[] arg20[i];
19819  }
19820  delete[] arg20;
19821  }
19822  }
19823  {
19824  if ( arg21 != NULL )
19825  delete [] arg21;
19826  }
19827  {
19828  if ( arg22 != NULL )
19829  delete [] arg22;
19830  }
19831  {
19832 
19833  }
19834  {
19835 
19836  }
19837  {
19838  if ( arg25 != NULL )
19839  delete [] arg25;
19840  }
19841  {
19842  if ( arg26 != NULL )
19843  delete [] arg26;
19844  }
19845  {
19846 
19847  }
19848  {
19849  if ( arg28 != NULL )
19850  delete [] arg28;
19851  }
19852  {
19853 
19854  }
19855  {
19856  if ( arg30 != NULL )
19857  delete [] arg30;
19858  }
19859  {
19860  int i;
19861  if ( arg31 != NULL )
19862  {
19863  for ( i = 0; i < Alen; i++ )
19864  {
19865  delete[] arg31[i];
19866  }
19867  delete[] arg31;
19868  }
19869  }
19870  return _out;
19871 fail:
19872  {
19873  delete [] arg14;
19874  }
19875  {
19876  delete [] arg19;
19877  }
19878  {
19879  int i;
19880  if ( arg20 != NULL )
19881  {
19882  for ( i = 0; i < Alen; i++ )
19883  {
19884  delete[] arg20[i];
19885  }
19886  delete[] arg20;
19887  }
19888  }
19889  {
19890  if ( arg21 != NULL )
19891  delete [] arg21;
19892  }
19893  {
19894  if ( arg22 != NULL )
19895  delete [] arg22;
19896  }
19897  {
19898 
19899  }
19900  {
19901 
19902  }
19903  {
19904  if ( arg25 != NULL )
19905  delete [] arg25;
19906  }
19907  {
19908  if ( arg26 != NULL )
19909  delete [] arg26;
19910  }
19911  {
19912 
19913  }
19914  {
19915  if ( arg28 != NULL )
19916  delete [] arg28;
19917  }
19918  {
19919 
19920  }
19921  {
19922  if ( arg30 != NULL )
19923  delete [] arg30;
19924  }
19925  {
19926  int i;
19927  if ( arg31 != NULL )
19928  {
19929  for ( i = 0; i < Alen; i++ )
19930  {
19931  delete[] arg31[i];
19932  }
19933  delete[] arg31;
19934  }
19935  }
19936  return octave_value_list();
19937 }
19938 
19939 
19941  PLFLT arg1 ;
19942  PLFLT arg2 ;
19943  PLFLT arg3 ;
19944  double val1 ;
19945  int ecode1 = 0 ;
19946  double val2 ;
19947  int ecode2 = 0 ;
19948  double val3 ;
19949  int ecode3 = 0 ;
19950  octave_value_list _out;
19951  octave_value_list *_outp=&_out;
19952  octave_value _outv;
19953 
19954  if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
19955  SWIG_fail;
19956  }
19957  ecode1 = SWIG_AsVal_double(args(0), &val1);
19958  if (!SWIG_IsOK(ecode1)) {
19959  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
19960  }
19961  arg1 = static_cast< PLFLT >(val1);
19962  ecode2 = SWIG_AsVal_double(args(1), &val2);
19963  if (!SWIG_IsOK(ecode2)) {
19964  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
19965  }
19966  arg2 = static_cast< PLFLT >(val2);
19967  ecode3 = SWIG_AsVal_double(args(2), &val3);
19968  if (!SWIG_IsOK(ecode3)) {
19969  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
19970  }
19971  arg3 = static_cast< PLFLT >(val3);
19972  pllightsource(arg1,arg2,arg3);
19973  _outv = octave_value();
19974  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19975  return _out;
19976 fail:
19977  return octave_value_list();
19978 }
19979 
19980 
19982  PLINT arg1 ;
19983  PLFLT *arg2 = (PLFLT *) 0 ;
19984  PLFLT *arg3 = (PLFLT *) 0 ;
19985  Matrix temp1 ;
19986  Matrix temp3 ;
19987  octave_value_list _out;
19988  octave_value_list *_outp=&_out;
19989  octave_value _outv;
19990 
19991  if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
19992  SWIG_fail;
19993  }
19994  {
19995  if ( _n_dims( args(0) ) > 1 )
19996  {
19997  error( "argument must be a scalar or vector" ); SWIG_fail;
19998  }
19999  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20000  temp1 = args(0).matrix_value();
20001  arg2 = &temp1( 0, 0 );
20002  }
20003  {
20004  if ( _n_dims( args(1) ) > 1 )
20005  {
20006  error( "argument must be a scalar or vector" ); SWIG_fail;
20007  }
20008  if ( _dim( args(1), 0 ) != Alen )
20009  {
20010  error( "argument vectors must be same length" ); SWIG_fail;
20011  }
20012  temp3 = args(1).matrix_value();
20013  arg3 = &temp3( 0, 0 );
20014  }
20015  plline(arg1,(double const *)arg2,(double const *)arg3);
20016  _outv = octave_value();
20017  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20018  {
20019 
20020  }
20021  {
20022 
20023  }
20024  return _out;
20025 fail:
20026  {
20027 
20028  }
20029  {
20030 
20031  }
20032  return octave_value_list();
20033 }
20034 
20035 
20037  PLINT arg1 ;
20038  PLFLT *arg2 = (PLFLT *) 0 ;
20039  PLFLT *arg3 = (PLFLT *) 0 ;
20040  PLFLT *arg4 = (PLFLT *) 0 ;
20041  Matrix temp1 ;
20042  Matrix temp3 ;
20043  Matrix temp4 ;
20044  octave_value_list _out;
20045  octave_value_list *_outp=&_out;
20046  octave_value _outv;
20047 
20048  if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
20049  SWIG_fail;
20050  }
20051  {
20052  if ( _n_dims( args(0) ) > 1 )
20053  {
20054  error( "argument must be a scalar or vector" ); SWIG_fail;
20055  }
20056  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20057  temp1 = args(0).matrix_value();
20058  arg2 = &temp1( 0, 0 );
20059  }
20060  {
20061  if ( _n_dims( args(1) ) > 1 )
20062  {
20063  error( "argument must be a scalar or vector" ); SWIG_fail;
20064  }
20065  if ( _dim( args(1), 0 ) != Alen )
20066  {
20067  error( "argument vectors must be same length" ); SWIG_fail;
20068  }
20069  temp3 = args(1).matrix_value();
20070  arg3 = &temp3( 0, 0 );
20071  }
20072  {
20073  if ( _n_dims( args(2) ) > 1 )
20074  {
20075  error( "argument must be a scalar or vector" ); SWIG_fail;
20076  }
20077  if ( _dim( args(2), 0 ) != Alen )
20078  {
20079  error( "argument vectors must be same length" ); SWIG_fail;
20080  }
20081  temp4 = args(2).matrix_value();
20082  arg4 = &temp4( 0, 0 );
20083  }
20084  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
20085  _outv = octave_value();
20086  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20087  {
20088 
20089  }
20090  {
20091 
20092  }
20093  {
20094 
20095  }
20096  return _out;
20097 fail:
20098  {
20099 
20100  }
20101  {
20102 
20103  }
20104  {
20105 
20106  }
20107  return octave_value_list();
20108 }
20109 
20110 
20112  PLINT arg1 ;
20113  int val1 ;
20114  int ecode1 = 0 ;
20115  octave_value_list _out;
20116  octave_value_list *_outp=&_out;
20117  octave_value _outv;
20118 
20119  if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
20120  SWIG_fail;
20121  }
20122  ecode1 = SWIG_AsVal_int(args(0), &val1);
20123  if (!SWIG_IsOK(ecode1)) {
20124  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
20125  }
20126  arg1 = static_cast< PLINT >(val1);
20127  pllsty(arg1);
20128  _outv = octave_value();
20129  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20130  return _out;
20131 fail:
20132  return octave_value_list();
20133 }
20134 
20135 
20137  PLINT *arg1 = (PLINT *) 0 ;
20138  PLINT temp1 ;
20139  int res1 = SWIG_TMPOBJ ;
20140  octave_value_list _out;
20141  octave_value_list *_outp=&_out;
20142  octave_value _outv;
20143 
20144  arg1 = &temp1;
20145  if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
20146  SWIG_fail;
20147  }
20148  plmkstrm(arg1);
20149  _outv = octave_value();
20150  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20151  if (SWIG_IsTmpObj(res1)) {
20152  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20153  } else {
20154  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20155  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20156  }
20157  return _out;
20158 fail:
20159  return octave_value_list();
20160 }
20161 
20162 
20164  char *arg1 = (char *) 0 ;
20165  PLFLT arg2 ;
20166  PLFLT arg3 ;
20167  PLFLT arg4 ;
20168  char *arg5 = (char *) 0 ;
20169  int res1 ;
20170  char *buf1 = 0 ;
20171  int alloc1 = 0 ;
20172  double val2 ;
20173  int ecode2 = 0 ;
20174  double val3 ;
20175  int ecode3 = 0 ;
20176  double val4 ;
20177  int ecode4 = 0 ;
20178  int res5 ;
20179  char *buf5 = 0 ;
20180  int alloc5 = 0 ;
20181  octave_value_list _out;
20182  octave_value_list *_outp=&_out;
20183  octave_value _outv;
20184 
20185  if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
20186  SWIG_fail;
20187  }
20188  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20189  if (!SWIG_IsOK(res1)) {
20190  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
20191  }
20192  arg1 = reinterpret_cast< char * >(buf1);
20193  ecode2 = SWIG_AsVal_double(args(1), &val2);
20194  if (!SWIG_IsOK(ecode2)) {
20195  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
20196  }
20197  arg2 = static_cast< PLFLT >(val2);
20198  ecode3 = SWIG_AsVal_double(args(2), &val3);
20199  if (!SWIG_IsOK(ecode3)) {
20200  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
20201  }
20202  arg3 = static_cast< PLFLT >(val3);
20203  ecode4 = SWIG_AsVal_double(args(3), &val4);
20204  if (!SWIG_IsOK(ecode4)) {
20205  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
20206  }
20207  arg4 = static_cast< PLFLT >(val4);
20208  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
20209  if (!SWIG_IsOK(res5)) {
20210  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
20211  }
20212  arg5 = reinterpret_cast< char * >(buf5);
20213  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
20214  _outv = octave_value();
20215  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20216  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20217  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20218  return _out;
20219 fail:
20220  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20221  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20222  return octave_value_list();
20223 }
20224 
20225 
20227  char *arg1 = (char *) 0 ;
20228  PLFLT arg2 ;
20229  PLFLT arg3 ;
20230  PLFLT arg4 ;
20231  char *arg5 = (char *) 0 ;
20232  int res1 ;
20233  char *buf1 = 0 ;
20234  int alloc1 = 0 ;
20235  double val2 ;
20236  int ecode2 = 0 ;
20237  double val3 ;
20238  int ecode3 = 0 ;
20239  double val4 ;
20240  int ecode4 = 0 ;
20241  int res5 ;
20242  char *buf5 = 0 ;
20243  int alloc5 = 0 ;
20244  octave_value_list _out;
20245  octave_value_list *_outp=&_out;
20246  octave_value _outv;
20247 
20248  if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
20249  SWIG_fail;
20250  }
20251  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20252  if (!SWIG_IsOK(res1)) {
20253  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
20254  }
20255  arg1 = reinterpret_cast< char * >(buf1);
20256  ecode2 = SWIG_AsVal_double(args(1), &val2);
20257  if (!SWIG_IsOK(ecode2)) {
20258  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
20259  }
20260  arg2 = static_cast< PLFLT >(val2);
20261  ecode3 = SWIG_AsVal_double(args(2), &val3);
20262  if (!SWIG_IsOK(ecode3)) {
20263  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
20264  }
20265  arg3 = static_cast< PLFLT >(val3);
20266  ecode4 = SWIG_AsVal_double(args(3), &val4);
20267  if (!SWIG_IsOK(ecode4)) {
20268  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
20269  }
20270  arg4 = static_cast< PLFLT >(val4);
20271  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
20272  if (!SWIG_IsOK(res5)) {
20273  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
20274  }
20275  arg5 = reinterpret_cast< char * >(buf5);
20276  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
20277  _outv = octave_value();
20278  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20279  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20280  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20281  return _out;
20282 fail:
20283  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20284  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20285  return octave_value_list();
20286 }
20287 
20288 
20290  int *arg1 = (int *) 0 ;
20291  char **arg2 = (char **) 0 ;
20292  PLINT arg3 ;
20293  void *argp1 = 0 ;
20294  int res1 = 0 ;
20295  void *argp2 = 0 ;
20296  int res2 = 0 ;
20297  int val3 ;
20298  int ecode3 = 0 ;
20299  octave_value_list _out;
20300  octave_value_list *_outp=&_out;
20301  octave_value _outv;
20302  PLINT result;
20303 
20304  if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
20305  SWIG_fail;
20306  }
20307  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
20308  if (!SWIG_IsOK(res1)) {
20309  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
20310  }
20311  arg1 = reinterpret_cast< int * >(argp1);
20312  res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
20313  if (!SWIG_IsOK(res2)) {
20314  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
20315  }
20316  arg2 = reinterpret_cast< char ** >(argp2);
20317  ecode3 = SWIG_AsVal_int(args(2), &val3);
20318  if (!SWIG_IsOK(ecode3)) {
20319  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
20320  }
20321  arg3 = static_cast< PLINT >(val3);
20322  result = (PLINT)plparseopts(arg1,arg2,arg3);
20323  _outv = SWIG_From_int(static_cast< int >(result));
20324  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20325  return _out;
20326 fail:
20327  return octave_value_list();
20328 }
20329 
20330 
20332  PLINT arg1 ;
20333  PLINT *arg2 = (PLINT *) 0 ;
20334  PLINT *arg3 = (PLINT *) 0 ;
20335  Matrix temp1 ;
20336  Matrix temp3 ;
20337  octave_value_list _out;
20338  octave_value_list *_outp=&_out;
20339  octave_value _outv;
20340 
20341  if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
20342  SWIG_fail;
20343  }
20344  {
20345  if ( _n_dims( args(0) ) > 1 )
20346  {
20347  error( "argument must be a scalar or vector" ); SWIG_fail;
20348  }
20349  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20350  arg2 = new PLINT[Alen];
20351  temp1 = args(0).matrix_value();
20352  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
20353  }
20354  {
20355  if ( _n_dims( args(1) ) > 1 )
20356  {
20357  error( "argument must be a scalar or vector" ); SWIG_fail;
20358  }
20359  if ( _dim( args(1), 0 ) != Alen )
20360  {
20361  error( "argument vectors must be same length" ); SWIG_fail;
20362  }
20363  temp3 = args(1).matrix_value();
20364  arg3 = new PLINT[Alen];
20365  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
20366  }
20367  plpat(arg1,(int const *)arg2,(int const *)arg3);
20368  _outv = octave_value();
20369  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20370  {
20371  delete [] arg2;
20372  }
20373  {
20374  delete [] arg3;
20375  }
20376  return _out;
20377 fail:
20378  {
20379  delete [] arg2;
20380  }
20381  {
20382  delete [] arg3;
20383  }
20384  return octave_value_list();
20385 }
20386 
20387 
20389  PLINT arg1 ;
20390  PLFLT arg2 ;
20391  PLFLT arg3 ;
20392  PLFLT arg4 ;
20393  PLFLT arg5 ;
20394  int val1 ;
20395  int ecode1 = 0 ;
20396  double val2 ;
20397  int ecode2 = 0 ;
20398  double val3 ;
20399  int ecode3 = 0 ;
20400  double val4 ;
20401  int ecode4 = 0 ;
20402  double val5 ;
20403  int ecode5 = 0 ;
20404  octave_value_list _out;
20405  octave_value_list *_outp=&_out;
20406  octave_value _outv;
20407 
20408  if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
20409  SWIG_fail;
20410  }
20411  ecode1 = SWIG_AsVal_int(args(0), &val1);
20412  if (!SWIG_IsOK(ecode1)) {
20413  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
20414  }
20415  arg1 = static_cast< PLINT >(val1);
20416  ecode2 = SWIG_AsVal_double(args(1), &val2);
20417  if (!SWIG_IsOK(ecode2)) {
20418  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
20419  }
20420  arg2 = static_cast< PLFLT >(val2);
20421  ecode3 = SWIG_AsVal_double(args(2), &val3);
20422  if (!SWIG_IsOK(ecode3)) {
20423  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
20424  }
20425  arg3 = static_cast< PLFLT >(val3);
20426  ecode4 = SWIG_AsVal_double(args(3), &val4);
20427  if (!SWIG_IsOK(ecode4)) {
20428  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
20429  }
20430  arg4 = static_cast< PLFLT >(val4);
20431  ecode5 = SWIG_AsVal_double(args(4), &val5);
20432  if (!SWIG_IsOK(ecode5)) {
20433  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
20434  }
20435  arg5 = static_cast< PLFLT >(val5);
20436  plpath(arg1,arg2,arg3,arg4,arg5);
20437  _outv = octave_value();
20438  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20439  return _out;
20440 fail:
20441  return octave_value_list();
20442 }
20443 
20444 
20446  PLINT arg1 ;
20447  PLFLT *arg2 = (PLFLT *) 0 ;
20448  PLFLT *arg3 = (PLFLT *) 0 ;
20449  PLINT arg4 ;
20450  Matrix temp1 ;
20451  Matrix temp3 ;
20452  int val4 ;
20453  int ecode4 = 0 ;
20454  octave_value_list _out;
20455  octave_value_list *_outp=&_out;
20456  octave_value _outv;
20457 
20458  if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
20459  SWIG_fail;
20460  }
20461  {
20462  if ( _n_dims( args(0) ) > 1 )
20463  {
20464  error( "argument must be a scalar or vector" ); SWIG_fail;
20465  }
20466  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20467  temp1 = args(0).matrix_value();
20468  arg2 = &temp1( 0, 0 );
20469  }
20470  {
20471  if ( _n_dims( args(1) ) > 1 )
20472  {
20473  error( "argument must be a scalar or vector" ); SWIG_fail;
20474  }
20475  if ( _dim( args(1), 0 ) != Alen )
20476  {
20477  error( "argument vectors must be same length" ); SWIG_fail;
20478  }
20479  temp3 = args(1).matrix_value();
20480  arg3 = &temp3( 0, 0 );
20481  }
20482  ecode4 = SWIG_AsVal_int(args(2), &val4);
20483  if (!SWIG_IsOK(ecode4)) {
20484  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
20485  }
20486  arg4 = static_cast< PLINT >(val4);
20487  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
20488  _outv = octave_value();
20489  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20490  {
20491 
20492  }
20493  {
20494 
20495  }
20496  return _out;
20497 fail:
20498  {
20499 
20500  }
20501  {
20502 
20503  }
20504  return octave_value_list();
20505 }
20506 
20507 
20509  PLINT arg1 ;
20510  PLFLT *arg2 = (PLFLT *) 0 ;
20511  PLFLT *arg3 = (PLFLT *) 0 ;
20512  PLFLT *arg4 = (PLFLT *) 0 ;
20513  PLINT arg5 ;
20514  Matrix temp1 ;
20515  Matrix temp3 ;
20516  Matrix temp4 ;
20517  int val5 ;
20518  int ecode5 = 0 ;
20519  octave_value_list _out;
20520  octave_value_list *_outp=&_out;
20521  octave_value _outv;
20522 
20523  if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
20524  SWIG_fail;
20525  }
20526  {
20527  if ( _n_dims( args(0) ) > 1 )
20528  {
20529  error( "argument must be a scalar or vector" ); SWIG_fail;
20530  }
20531  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20532  temp1 = args(0).matrix_value();
20533  arg2 = &temp1( 0, 0 );
20534  }
20535  {
20536  if ( _n_dims( args(1) ) > 1 )
20537  {
20538  error( "argument must be a scalar or vector" ); SWIG_fail;
20539  }
20540  if ( _dim( args(1), 0 ) != Alen )
20541  {
20542  error( "argument vectors must be same length" ); SWIG_fail;
20543  }
20544  temp3 = args(1).matrix_value();
20545  arg3 = &temp3( 0, 0 );
20546  }
20547  {
20548  if ( _n_dims( args(2) ) > 1 )
20549  {
20550  error( "argument must be a scalar or vector" ); SWIG_fail;
20551  }
20552  if ( _dim( args(2), 0 ) != Alen )
20553  {
20554  error( "argument vectors must be same length" ); SWIG_fail;
20555  }
20556  temp4 = args(2).matrix_value();
20557  arg4 = &temp4( 0, 0 );
20558  }
20559  ecode5 = SWIG_AsVal_int(args(3), &val5);
20560  if (!SWIG_IsOK(ecode5)) {
20561  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
20562  }
20563  arg5 = static_cast< PLINT >(val5);
20564  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
20565  _outv = octave_value();
20566  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20567  {
20568 
20569  }
20570  {
20571 
20572  }
20573  {
20574 
20575  }
20576  return _out;
20577 fail:
20578  {
20579 
20580  }
20581  {
20582 
20583  }
20584  {
20585 
20586  }
20587  return octave_value_list();
20588 }
20589 
20590 
20592  PLINT arg1 ;
20593  PLFLT *arg2 = (PLFLT *) 0 ;
20594  PLFLT *arg3 = (PLFLT *) 0 ;
20595  PLFLT *arg4 = (PLFLT *) 0 ;
20596  PLBOOL *arg5 = (PLBOOL *) 0 ;
20597  PLBOOL arg6 ;
20598  Matrix temp1 ;
20599  Matrix temp3 ;
20600  Matrix temp4 ;
20601  Matrix temp5 ;
20602  int val6 ;
20603  int ecode6 = 0 ;
20604  octave_value_list _out;
20605  octave_value_list *_outp=&_out;
20606  octave_value _outv;
20607 
20608  if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
20609  SWIG_fail;
20610  }
20611  {
20612  if ( _n_dims( args(0) ) > 1 )
20613  {
20614  error( "argument must be a scalar or vector" ); SWIG_fail;
20615  }
20616  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20617  temp1 = args(0).matrix_value();
20618  arg2 = &temp1( 0, 0 );
20619  }
20620  {
20621  if ( _n_dims( args(1) ) > 1 )
20622  {
20623  error( "argument must be a scalar or vector" ); SWIG_fail;
20624  }
20625  if ( _dim( args(1), 0 ) != Alen )
20626  {
20627  error( "argument vectors must be same length" ); SWIG_fail;
20628  }
20629  temp3 = args(1).matrix_value();
20630  arg3 = &temp3( 0, 0 );
20631  }
20632  {
20633  if ( _n_dims( args(2) ) > 1 )
20634  {
20635  error( "argument must be a scalar or vector" ); SWIG_fail;
20636  }
20637  if ( _dim( args(2), 0 ) != Alen )
20638  {
20639  error( "argument vectors must be same length" ); SWIG_fail;
20640  }
20641  temp4 = args(2).matrix_value();
20642  arg4 = &temp4( 0, 0 );
20643  }
20644  {
20645  if ( _n_dims( args(3) ) > 1 )
20646  {
20647  error( "argument must be a scalar or vector" ); SWIG_fail;
20648  }
20649  if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
20650  {
20651  error( "argument vector must be same length or one less" ); SWIG_fail;
20652  }
20653  temp5 = args(3).matrix_value();
20654  arg5 = new PLINT[Alen];
20655  _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
20656  }
20657  ecode6 = SWIG_AsVal_int(args(4), &val6);
20658  if (!SWIG_IsOK(ecode6)) {
20659  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
20660  }
20661  arg6 = static_cast< PLBOOL >(val6);
20662  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
20663  _outv = octave_value();
20664  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20665  {
20666 
20667  }
20668  {
20669 
20670  }
20671  {
20672 
20673  }
20674  {
20675  delete [] arg5;
20676  }
20677  return _out;
20678 fail:
20679  {
20680 
20681  }
20682  {
20683 
20684  }
20685  {
20686 
20687  }
20688  {
20689  delete [] arg5;
20690  }
20691  return octave_value_list();
20692 }
20693 
20694 
20696  PLINT arg1 ;
20697  PLINT arg2 ;
20698  int val1 ;
20699  int ecode1 = 0 ;
20700  int val2 ;
20701  int ecode2 = 0 ;
20702  octave_value_list _out;
20703  octave_value_list *_outp=&_out;
20704  octave_value _outv;
20705 
20706  if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
20707  SWIG_fail;
20708  }
20709  ecode1 = SWIG_AsVal_int(args(0), &val1);
20710  if (!SWIG_IsOK(ecode1)) {
20711  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
20712  }
20713  arg1 = static_cast< PLINT >(val1);
20714  ecode2 = SWIG_AsVal_int(args(1), &val2);
20715  if (!SWIG_IsOK(ecode2)) {
20716  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
20717  }
20718  arg2 = static_cast< PLINT >(val2);
20719  plprec(arg1,arg2);
20720  _outv = octave_value();
20721  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20722  return _out;
20723 fail:
20724  return octave_value_list();
20725 }
20726 
20727 
20729  PLINT arg1 ;
20730  int val1 ;
20731  int ecode1 = 0 ;
20732  octave_value_list _out;
20733  octave_value_list *_outp=&_out;
20734  octave_value _outv;
20735 
20736  if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
20737  SWIG_fail;
20738  }
20739  ecode1 = SWIG_AsVal_int(args(0), &val1);
20740  if (!SWIG_IsOK(ecode1)) {
20741  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
20742  }
20743  arg1 = static_cast< PLINT >(val1);
20744  plpsty(arg1);
20745  _outv = octave_value();
20746  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20747  return _out;
20748 fail:
20749  return octave_value_list();
20750 }
20751 
20752 
20754  PLFLT arg1 ;
20755  PLFLT arg2 ;
20756  PLFLT arg3 ;
20757  PLFLT arg4 ;
20758  PLFLT arg5 ;
20759  char *arg6 = (char *) 0 ;
20760  double val1 ;
20761  int ecode1 = 0 ;
20762  double val2 ;
20763  int ecode2 = 0 ;
20764  double val3 ;
20765  int ecode3 = 0 ;
20766  double val4 ;
20767  int ecode4 = 0 ;
20768  double val5 ;
20769  int ecode5 = 0 ;
20770  int res6 ;
20771  char *buf6 = 0 ;
20772  int alloc6 = 0 ;
20773  octave_value_list _out;
20774  octave_value_list *_outp=&_out;
20775  octave_value _outv;
20776 
20777  if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
20778  SWIG_fail;
20779  }
20780  ecode1 = SWIG_AsVal_double(args(0), &val1);
20781  if (!SWIG_IsOK(ecode1)) {
20782  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
20783  }
20784  arg1 = static_cast< PLFLT >(val1);
20785  ecode2 = SWIG_AsVal_double(args(1), &val2);
20786  if (!SWIG_IsOK(ecode2)) {
20787  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
20788  }
20789  arg2 = static_cast< PLFLT >(val2);
20790  ecode3 = SWIG_AsVal_double(args(2), &val3);
20791  if (!SWIG_IsOK(ecode3)) {
20792  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
20793  }
20794  arg3 = static_cast< PLFLT >(val3);
20795  ecode4 = SWIG_AsVal_double(args(3), &val4);
20796  if (!SWIG_IsOK(ecode4)) {
20797  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
20798  }
20799  arg4 = static_cast< PLFLT >(val4);
20800  ecode5 = SWIG_AsVal_double(args(4), &val5);
20801  if (!SWIG_IsOK(ecode5)) {
20802  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
20803  }
20804  arg5 = static_cast< PLFLT >(val5);
20805  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
20806  if (!SWIG_IsOK(res6)) {
20807  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
20808  }
20809  arg6 = reinterpret_cast< char * >(buf6);
20810  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
20811  _outv = octave_value();
20812  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20813  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
20814  return _out;
20815 fail:
20816  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
20817  return octave_value_list();
20818 }
20819 
20820 
20822  PLFLT arg1 ;
20823  PLFLT arg2 ;
20824  PLFLT arg3 ;
20825  PLFLT arg4 ;
20826  PLFLT arg5 ;
20827  PLFLT arg6 ;
20828  PLFLT arg7 ;
20829  PLFLT arg8 ;
20830  PLFLT arg9 ;
20831  PLFLT arg10 ;
20832  char *arg11 = (char *) 0 ;
20833  double val1 ;
20834  int ecode1 = 0 ;
20835  double val2 ;
20836  int ecode2 = 0 ;
20837  double val3 ;
20838  int ecode3 = 0 ;
20839  double val4 ;
20840  int ecode4 = 0 ;
20841  double val5 ;
20842  int ecode5 = 0 ;
20843  double val6 ;
20844  int ecode6 = 0 ;
20845  double val7 ;
20846  int ecode7 = 0 ;
20847  double val8 ;
20848  int ecode8 = 0 ;
20849  double val9 ;
20850  int ecode9 = 0 ;
20851  double val10 ;
20852  int ecode10 = 0 ;
20853  int res11 ;
20854  char *buf11 = 0 ;
20855  int alloc11 = 0 ;
20856  octave_value_list _out;
20857  octave_value_list *_outp=&_out;
20858  octave_value _outv;
20859 
20860  if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
20861  SWIG_fail;
20862  }
20863  ecode1 = SWIG_AsVal_double(args(0), &val1);
20864  if (!SWIG_IsOK(ecode1)) {
20865  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
20866  }
20867  arg1 = static_cast< PLFLT >(val1);
20868  ecode2 = SWIG_AsVal_double(args(1), &val2);
20869  if (!SWIG_IsOK(ecode2)) {
20870  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
20871  }
20872  arg2 = static_cast< PLFLT >(val2);
20873  ecode3 = SWIG_AsVal_double(args(2), &val3);
20874  if (!SWIG_IsOK(ecode3)) {
20875  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
20876  }
20877  arg3 = static_cast< PLFLT >(val3);
20878  ecode4 = SWIG_AsVal_double(args(3), &val4);
20879  if (!SWIG_IsOK(ecode4)) {
20880  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
20881  }
20882  arg4 = static_cast< PLFLT >(val4);
20883  ecode5 = SWIG_AsVal_double(args(4), &val5);
20884  if (!SWIG_IsOK(ecode5)) {
20885  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
20886  }
20887  arg5 = static_cast< PLFLT >(val5);
20888  ecode6 = SWIG_AsVal_double(args(5), &val6);
20889  if (!SWIG_IsOK(ecode6)) {
20890  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
20891  }
20892  arg6 = static_cast< PLFLT >(val6);
20893  ecode7 = SWIG_AsVal_double(args(6), &val7);
20894  if (!SWIG_IsOK(ecode7)) {
20895  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
20896  }
20897  arg7 = static_cast< PLFLT >(val7);
20898  ecode8 = SWIG_AsVal_double(args(7), &val8);
20899  if (!SWIG_IsOK(ecode8)) {
20900  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
20901  }
20902  arg8 = static_cast< PLFLT >(val8);
20903  ecode9 = SWIG_AsVal_double(args(8), &val9);
20904  if (!SWIG_IsOK(ecode9)) {
20905  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
20906  }
20907  arg9 = static_cast< PLFLT >(val9);
20908  ecode10 = SWIG_AsVal_double(args(9), &val10);
20909  if (!SWIG_IsOK(ecode10)) {
20910  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
20911  }
20912  arg10 = static_cast< PLFLT >(val10);
20913  res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
20914  if (!SWIG_IsOK(res11)) {
20915  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
20916  }
20917  arg11 = reinterpret_cast< char * >(buf11);
20918  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
20919  _outv = octave_value();
20920  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20921  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
20922  return _out;
20923 fail:
20924  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
20925  return octave_value_list();
20926 }
20927 
20928 
20930  octave_value_list _out;
20931  octave_value_list *_outp=&_out;
20932  octave_value _outv;
20933  PLFLT result;
20934 
20935  if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
20936  SWIG_fail;
20937  }
20938  result = (PLFLT)plrandd();
20939  _outv = SWIG_From_double(static_cast< double >(result));
20940  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20941  return _out;
20942 fail:
20943  return octave_value_list();
20944 }
20945 
20946 
20948  octave_value_list _out;
20949  octave_value_list *_outp=&_out;
20950  octave_value _outv;
20951 
20952  if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
20953  SWIG_fail;
20954  }
20955  plreplot();
20956  _outv = octave_value();
20957  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20958  return _out;
20959 fail:
20960  return octave_value_list();
20961 }
20962 
20963 
20965  PLFLT arg1 ;
20966  PLFLT arg2 ;
20967  PLFLT arg3 ;
20968  PLFLT *arg4 = (PLFLT *) 0 ;
20969  PLFLT *arg5 = (PLFLT *) 0 ;
20970  PLFLT *arg6 = (PLFLT *) 0 ;
20971  double val1 ;
20972  int ecode1 = 0 ;
20973  double val2 ;
20974  int ecode2 = 0 ;
20975  double val3 ;
20976  int ecode3 = 0 ;
20977  PLFLT temp4 ;
20978  int res4 = SWIG_TMPOBJ ;
20979  PLFLT temp5 ;
20980  int res5 = SWIG_TMPOBJ ;
20981  PLFLT temp6 ;
20982  int res6 = SWIG_TMPOBJ ;
20983  octave_value_list _out;
20984  octave_value_list *_outp=&_out;
20985  octave_value _outv;
20986 
20987  arg4 = &temp4;
20988  arg5 = &temp5;
20989  arg6 = &temp6;
20990  if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
20991  SWIG_fail;
20992  }
20993  ecode1 = SWIG_AsVal_double(args(0), &val1);
20994  if (!SWIG_IsOK(ecode1)) {
20995  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
20996  }
20997  arg1 = static_cast< PLFLT >(val1);
20998  ecode2 = SWIG_AsVal_double(args(1), &val2);
20999  if (!SWIG_IsOK(ecode2)) {
21000  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
21001  }
21002  arg2 = static_cast< PLFLT >(val2);
21003  ecode3 = SWIG_AsVal_double(args(2), &val3);
21004  if (!SWIG_IsOK(ecode3)) {
21005  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
21006  }
21007  arg3 = static_cast< PLFLT >(val3);
21008  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
21009  _outv = octave_value();
21010  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21011  if (SWIG_IsTmpObj(res4)) {
21012  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
21013  } else {
21014  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21015  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
21016  }
21017  if (SWIG_IsTmpObj(res5)) {
21018  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
21019  } else {
21020  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21021  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
21022  }
21023  if (SWIG_IsTmpObj(res6)) {
21024  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
21025  } else {
21026  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21027  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
21028  }
21029  return _out;
21030 fail:
21031  return octave_value_list();
21032 }
21033 
21034 
21036  PLFLT arg1 ;
21037  PLFLT arg2 ;
21038  double val1 ;
21039  int ecode1 = 0 ;
21040  double val2 ;
21041  int ecode2 = 0 ;
21042  octave_value_list _out;
21043  octave_value_list *_outp=&_out;
21044  octave_value _outv;
21045 
21046  if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
21047  SWIG_fail;
21048  }
21049  ecode1 = SWIG_AsVal_double(args(0), &val1);
21050  if (!SWIG_IsOK(ecode1)) {
21051  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
21052  }
21053  arg1 = static_cast< PLFLT >(val1);
21054  ecode2 = SWIG_AsVal_double(args(1), &val2);
21055  if (!SWIG_IsOK(ecode2)) {
21056  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
21057  }
21058  arg2 = static_cast< PLFLT >(val2);
21059  plschr(arg1,arg2);
21060  _outv = octave_value();
21061  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21062  return _out;
21063 fail:
21064  return octave_value_list();
21065 }
21066 
21067 
21069  PLINT *arg1 = (PLINT *) 0 ;
21070  PLINT *arg2 = (PLINT *) 0 ;
21071  PLINT *arg3 = (PLINT *) 0 ;
21072  PLINT arg4 ;
21073  Matrix temp1 ;
21074  Matrix temp2 ;
21075  Matrix temp3 ;
21076  octave_value_list _out;
21077  octave_value_list *_outp=&_out;
21078  octave_value _outv;
21079 
21080  if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
21081  SWIG_fail;
21082  }
21083  {
21084  if ( _n_dims( args(0) ) > 1 )
21085  {
21086  error( "argument must be a scalar or vector" ); SWIG_fail;
21087  }
21088  Alen = (PLINT) ( _dim( args(0), 0 ) );
21089  temp1 = args(0).matrix_value();
21090  arg1 = new PLINT[Alen];
21091  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21092  }
21093  {
21094  if ( _n_dims( args(1) ) > 1 )
21095  {
21096  error( "argument must be a scalar or vector" ); SWIG_fail;
21097  }
21098  if ( _dim( args(1), 0 ) != Alen )
21099  {
21100  error( "argument vectors must be same length" ); SWIG_fail;
21101  }
21102  temp2 = args(1).matrix_value();
21103  arg2 = new PLINT[Alen];
21104  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21105  }
21106  {
21107  if ( _n_dims( args(2) ) > 1 )
21108  {
21109  error( "argument must be a scalar or vector" ); SWIG_fail;
21110  }
21111  if ( _dim( args(2), 0 ) != Alen )
21112  {
21113  error( "argument vectors must be same length" ); SWIG_fail;
21114  }
21115  temp3 = args(2).matrix_value();
21116  arg3 = new PLINT[Alen];
21117  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21118  arg4 = Alen;
21119  }
21120  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
21121  _outv = octave_value();
21122  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21123  {
21124  delete [] arg1;
21125  }
21126  {
21127  delete [] arg2;
21128  }
21129  {
21130  delete [] arg3;
21131  }
21132  return _out;
21133 fail:
21134  {
21135  delete [] arg1;
21136  }
21137  {
21138  delete [] arg2;
21139  }
21140  {
21141  delete [] arg3;
21142  }
21143  return octave_value_list();
21144 }
21145 
21146 
21148  PLINT *arg1 = (PLINT *) 0 ;
21149  PLINT *arg2 = (PLINT *) 0 ;
21150  PLINT *arg3 = (PLINT *) 0 ;
21151  PLFLT *arg4 = (PLFLT *) 0 ;
21152  PLINT arg5 ;
21153  Matrix temp1 ;
21154  Matrix temp2 ;
21155  Matrix temp3 ;
21156  Matrix temp4 ;
21157  octave_value_list _out;
21158  octave_value_list *_outp=&_out;
21159  octave_value _outv;
21160 
21161  if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
21162  SWIG_fail;
21163  }
21164  {
21165  if ( _n_dims( args(0) ) > 1 )
21166  {
21167  error( "argument must be a scalar or vector" ); SWIG_fail;
21168  }
21169  Alen = (PLINT) ( _dim( args(0), 0 ) );
21170  temp1 = args(0).matrix_value();
21171  arg1 = new PLINT[Alen];
21172  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21173  }
21174  {
21175  if ( _n_dims( args(1) ) > 1 )
21176  {
21177  error( "argument must be a scalar or vector" ); SWIG_fail;
21178  }
21179  if ( _dim( args(1), 0 ) != Alen )
21180  {
21181  error( "argument vectors must be same length" ); SWIG_fail;
21182  }
21183  temp2 = args(1).matrix_value();
21184  arg2 = new PLINT[Alen];
21185  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21186  }
21187  {
21188  if ( _n_dims( args(2) ) > 1 )
21189  {
21190  error( "argument must be a scalar or vector" ); SWIG_fail;
21191  }
21192  if ( _dim( args(2), 0 ) != Alen )
21193  {
21194  error( "argument vectors must be same length" ); SWIG_fail;
21195  }
21196  temp3 = args(2).matrix_value();
21197  arg3 = new PLINT[Alen];
21198  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21199  }
21200  {
21201  if ( _n_dims( args(3) ) > 1 )
21202  {
21203  error( "argument must be a scalar or vector" ); SWIG_fail;
21204  }
21205  if ( _dim( args(3), 0 ) != Alen )
21206  {
21207  error( "argument vectors must be same length" ); SWIG_fail;
21208  }
21209  temp4 = args(3).matrix_value();
21210  arg4 = &temp4( 0, 0 );
21211  arg5 = (PLINT) ( _dim( args(3), 0 ) );
21212  }
21213  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
21214  _outv = octave_value();
21215  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21216  {
21217  delete [] arg1;
21218  }
21219  {
21220  delete [] arg2;
21221  }
21222  {
21223  delete [] arg3;
21224  }
21225  {
21226 
21227  }
21228  return _out;
21229 fail:
21230  {
21231  delete [] arg1;
21232  }
21233  {
21234  delete [] arg2;
21235  }
21236  {
21237  delete [] arg3;
21238  }
21239  {
21240 
21241  }
21242  return octave_value_list();
21243 }
21244 
21245 
21247  PLINT arg1 ;
21248  int val1 ;
21249  int ecode1 = 0 ;
21250  octave_value_list _out;
21251  octave_value_list *_outp=&_out;
21252  octave_value _outv;
21253 
21254  if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
21255  SWIG_fail;
21256  }
21257  ecode1 = SWIG_AsVal_int(args(0), &val1);
21258  if (!SWIG_IsOK(ecode1)) {
21259  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
21260  }
21261  arg1 = static_cast< PLINT >(val1);
21262  plscmap0n(arg1);
21263  _outv = octave_value();
21264  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21265  return _out;
21266 fail:
21267  return octave_value_list();
21268 }
21269 
21270 
21272  PLINT *arg1 = (PLINT *) 0 ;
21273  PLINT *arg2 = (PLINT *) 0 ;
21274  PLINT *arg3 = (PLINT *) 0 ;
21275  PLINT arg4 ;
21276  Matrix temp1 ;
21277  Matrix temp2 ;
21278  Matrix temp3 ;
21279  octave_value_list _out;
21280  octave_value_list *_outp=&_out;
21281  octave_value _outv;
21282 
21283  if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
21284  SWIG_fail;
21285  }
21286  {
21287  if ( _n_dims( args(0) ) > 1 )
21288  {
21289  error( "argument must be a scalar or vector" ); SWIG_fail;
21290  }
21291  Alen = (PLINT) ( _dim( args(0), 0 ) );
21292  temp1 = args(0).matrix_value();
21293  arg1 = new PLINT[Alen];
21294  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21295  }
21296  {
21297  if ( _n_dims( args(1) ) > 1 )
21298  {
21299  error( "argument must be a scalar or vector" ); SWIG_fail;
21300  }
21301  if ( _dim( args(1), 0 ) != Alen )
21302  {
21303  error( "argument vectors must be same length" ); SWIG_fail;
21304  }
21305  temp2 = args(1).matrix_value();
21306  arg2 = new PLINT[Alen];
21307  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21308  }
21309  {
21310  if ( _n_dims( args(2) ) > 1 )
21311  {
21312  error( "argument must be a scalar or vector" ); SWIG_fail;
21313  }
21314  if ( _dim( args(2), 0 ) != Alen )
21315  {
21316  error( "argument vectors must be same length" ); SWIG_fail;
21317  }
21318  temp3 = args(2).matrix_value();
21319  arg3 = new PLINT[Alen];
21320  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21321  arg4 = Alen;
21322  }
21323  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
21324  _outv = octave_value();
21325  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21326  {
21327  delete [] arg1;
21328  }
21329  {
21330  delete [] arg2;
21331  }
21332  {
21333  delete [] arg3;
21334  }
21335  return _out;
21336 fail:
21337  {
21338  delete [] arg1;
21339  }
21340  {
21341  delete [] arg2;
21342  }
21343  {
21344  delete [] arg3;
21345  }
21346  return octave_value_list();
21347 }
21348 
21349 
21351  PLINT *arg1 = (PLINT *) 0 ;
21352  PLINT *arg2 = (PLINT *) 0 ;
21353  PLINT *arg3 = (PLINT *) 0 ;
21354  PLFLT *arg4 = (PLFLT *) 0 ;
21355  PLINT arg5 ;
21356  Matrix temp1 ;
21357  Matrix temp2 ;
21358  Matrix temp3 ;
21359  Matrix temp4 ;
21360  octave_value_list _out;
21361  octave_value_list *_outp=&_out;
21362  octave_value _outv;
21363 
21364  if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
21365  SWIG_fail;
21366  }
21367  {
21368  if ( _n_dims( args(0) ) > 1 )
21369  {
21370  error( "argument must be a scalar or vector" ); SWIG_fail;
21371  }
21372  Alen = (PLINT) ( _dim( args(0), 0 ) );
21373  temp1 = args(0).matrix_value();
21374  arg1 = new PLINT[Alen];
21375  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21376  }
21377  {
21378  if ( _n_dims( args(1) ) > 1 )
21379  {
21380  error( "argument must be a scalar or vector" ); SWIG_fail;
21381  }
21382  if ( _dim( args(1), 0 ) != Alen )
21383  {
21384  error( "argument vectors must be same length" ); SWIG_fail;
21385  }
21386  temp2 = args(1).matrix_value();
21387  arg2 = new PLINT[Alen];
21388  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21389  }
21390  {
21391  if ( _n_dims( args(2) ) > 1 )
21392  {
21393  error( "argument must be a scalar or vector" ); SWIG_fail;
21394  }
21395  if ( _dim( args(2), 0 ) != Alen )
21396  {
21397  error( "argument vectors must be same length" ); SWIG_fail;
21398  }
21399  temp3 = args(2).matrix_value();
21400  arg3 = new PLINT[Alen];
21401  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21402  }
21403  {
21404  if ( _n_dims( args(3) ) > 1 )
21405  {
21406  error( "argument must be a scalar or vector" ); SWIG_fail;
21407  }
21408  if ( _dim( args(3), 0 ) != Alen )
21409  {
21410  error( "argument vectors must be same length" ); SWIG_fail;
21411  }
21412  temp4 = args(3).matrix_value();
21413  arg4 = &temp4( 0, 0 );
21414  arg5 = (PLINT) ( _dim( args(3), 0 ) );
21415  }
21416  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
21417  _outv = octave_value();
21418  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21419  {
21420  delete [] arg1;
21421  }
21422  {
21423  delete [] arg2;
21424  }
21425  {
21426  delete [] arg3;
21427  }
21428  {
21429 
21430  }
21431  return _out;
21432 fail:
21433  {
21434  delete [] arg1;
21435  }
21436  {
21437  delete [] arg2;
21438  }
21439  {
21440  delete [] arg3;
21441  }
21442  {
21443 
21444  }
21445  return octave_value_list();
21446 }
21447 
21448 
21450  PLBOOL arg1 ;
21451  PLINT arg2 ;
21452  PLFLT *arg3 = (PLFLT *) 0 ;
21453  PLFLT *arg4 = (PLFLT *) 0 ;
21454  PLFLT *arg5 = (PLFLT *) 0 ;
21455  PLFLT *arg6 = (PLFLT *) 0 ;
21456  PLBOOL *arg7 = (PLBOOL *) 0 ;
21457  int val1 ;
21458  int ecode1 = 0 ;
21459  Matrix temp2 ;
21460  Matrix temp4 ;
21461  Matrix temp5 ;
21462  Matrix temp6 ;
21463  Matrix temp7 ;
21464  octave_value_list _out;
21465  octave_value_list *_outp=&_out;
21466  octave_value _outv;
21467 
21468  if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
21469  SWIG_fail;
21470  }
21471  ecode1 = SWIG_AsVal_int(args(0), &val1);
21472  if (!SWIG_IsOK(ecode1)) {
21473  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
21474  }
21475  arg1 = static_cast< PLBOOL >(val1);
21476  {
21477  if ( _n_dims( args(1) ) > 1 )
21478  {
21479  error( "argument must be a scalar or vector" ); SWIG_fail;
21480  }
21481  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
21482  temp2 = args(1).matrix_value();
21483  arg3 = &temp2( 0, 0 );
21484  }
21485  {
21486  if ( _n_dims( args(2) ) > 1 )
21487  {
21488  error( "argument must be a scalar or vector" ); SWIG_fail;
21489  }
21490  if ( _dim( args(2), 0 ) != Alen )
21491  {
21492  error( "argument vectors must be same length" ); SWIG_fail;
21493  }
21494  temp4 = args(2).matrix_value();
21495  arg4 = &temp4( 0, 0 );
21496  }
21497  {
21498  if ( _n_dims( args(3) ) > 1 )
21499  {
21500  error( "argument must be a scalar or vector" ); SWIG_fail;
21501  }
21502  if ( _dim( args(3), 0 ) != Alen )
21503  {
21504  error( "argument vectors must be same length" ); SWIG_fail;
21505  }
21506  temp5 = args(3).matrix_value();
21507  arg5 = &temp5( 0, 0 );
21508  }
21509  {
21510  if ( _n_dims( args(4) ) > 1 )
21511  {
21512  error( "argument must be a scalar or vector" ); SWIG_fail;
21513  }
21514  if ( _dim( args(4), 0 ) != Alen )
21515  {
21516  error( "argument vectors must be same length" ); SWIG_fail;
21517  }
21518  temp6 = args(4).matrix_value();
21519  arg6 = &temp6( 0, 0 );
21520  }
21521  {
21522  if ( _n_dims( args(5) ) > 1 )
21523  {
21524  error( "argument must be a scalar or vector" ); SWIG_fail;
21525  }
21526  if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
21527  {
21528  error( "argument vector must be same length or one less" ); SWIG_fail;
21529  }
21530  temp7 = args(5).matrix_value();
21531  arg7 = new PLINT[Alen];
21532  _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
21533  }
21534  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
21535  _outv = octave_value();
21536  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21537  {
21538 
21539  }
21540  {
21541 
21542  }
21543  {
21544 
21545  }
21546  {
21547 
21548  }
21549  {
21550  delete [] arg7;
21551  }
21552  return _out;
21553 fail:
21554  {
21555 
21556  }
21557  {
21558 
21559  }
21560  {
21561 
21562  }
21563  {
21564 
21565  }
21566  {
21567  delete [] arg7;
21568  }
21569  return octave_value_list();
21570 }
21571 
21572 
21574  PLBOOL arg1 ;
21575  PLINT arg2 ;
21576  PLFLT *arg3 = (PLFLT *) 0 ;
21577  PLFLT *arg4 = (PLFLT *) 0 ;
21578  PLFLT *arg5 = (PLFLT *) 0 ;
21579  PLFLT *arg6 = (PLFLT *) 0 ;
21580  PLFLT *arg7 = (PLFLT *) 0 ;
21581  PLBOOL *arg8 = (PLBOOL *) 0 ;
21582  int val1 ;
21583  int ecode1 = 0 ;
21584  Matrix temp2 ;
21585  Matrix temp4 ;
21586  Matrix temp5 ;
21587  Matrix temp6 ;
21588  Matrix temp7 ;
21589  Matrix temp8 ;
21590  octave_value_list _out;
21591  octave_value_list *_outp=&_out;
21592  octave_value _outv;
21593 
21594  if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
21595  SWIG_fail;
21596  }
21597  ecode1 = SWIG_AsVal_int(args(0), &val1);
21598  if (!SWIG_IsOK(ecode1)) {
21599  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
21600  }
21601  arg1 = static_cast< PLBOOL >(val1);
21602  {
21603  if ( _n_dims( args(1) ) > 1 )
21604  {
21605  error( "argument must be a scalar or vector" ); SWIG_fail;
21606  }
21607  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
21608  temp2 = args(1).matrix_value();
21609  arg3 = &temp2( 0, 0 );
21610  }
21611  {
21612  if ( _n_dims( args(2) ) > 1 )
21613  {
21614  error( "argument must be a scalar or vector" ); SWIG_fail;
21615  }
21616  if ( _dim( args(2), 0 ) != Alen )
21617  {
21618  error( "argument vectors must be same length" ); SWIG_fail;
21619  }
21620  temp4 = args(2).matrix_value();
21621  arg4 = &temp4( 0, 0 );
21622  }
21623  {
21624  if ( _n_dims( args(3) ) > 1 )
21625  {
21626  error( "argument must be a scalar or vector" ); SWIG_fail;
21627  }
21628  if ( _dim( args(3), 0 ) != Alen )
21629  {
21630  error( "argument vectors must be same length" ); SWIG_fail;
21631  }
21632  temp5 = args(3).matrix_value();
21633  arg5 = &temp5( 0, 0 );
21634  }
21635  {
21636  if ( _n_dims( args(4) ) > 1 )
21637  {
21638  error( "argument must be a scalar or vector" ); SWIG_fail;
21639  }
21640  if ( _dim( args(4), 0 ) != Alen )
21641  {
21642  error( "argument vectors must be same length" ); SWIG_fail;
21643  }
21644  temp6 = args(4).matrix_value();
21645  arg6 = &temp6( 0, 0 );
21646  }
21647  {
21648  if ( _n_dims( args(5) ) > 1 )
21649  {
21650  error( "argument must be a scalar or vector" ); SWIG_fail;
21651  }
21652  if ( _dim( args(5), 0 ) != Alen )
21653  {
21654  error( "argument vectors must be same length" ); SWIG_fail;
21655  }
21656  temp7 = args(5).matrix_value();
21657  arg7 = &temp7( 0, 0 );
21658  }
21659  {
21660  if ( _n_dims( args(6) ) > 1 )
21661  {
21662  error( "argument must be a scalar or vector" ); SWIG_fail;
21663  }
21664  if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
21665  {
21666  error( "argument vector must be same length or one less" ); SWIG_fail;
21667  }
21668  temp8 = args(6).matrix_value();
21669  arg8 = new PLINT[Alen];
21670  _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
21671  }
21672  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
21673  _outv = octave_value();
21674  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21675  {
21676 
21677  }
21678  {
21679 
21680  }
21681  {
21682 
21683  }
21684  {
21685 
21686  }
21687  {
21688 
21689  }
21690  {
21691  delete [] arg8;
21692  }
21693  return _out;
21694 fail:
21695  {
21696 
21697  }
21698  {
21699 
21700  }
21701  {
21702 
21703  }
21704  {
21705 
21706  }
21707  {
21708 
21709  }
21710  {
21711  delete [] arg8;
21712  }
21713  return octave_value_list();
21714 }
21715 
21716 
21718  PLINT arg1 ;
21719  int val1 ;
21720  int ecode1 = 0 ;
21721  octave_value_list _out;
21722  octave_value_list *_outp=&_out;
21723  octave_value _outv;
21724 
21725  if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
21726  SWIG_fail;
21727  }
21728  ecode1 = SWIG_AsVal_int(args(0), &val1);
21729  if (!SWIG_IsOK(ecode1)) {
21730  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
21731  }
21732  arg1 = static_cast< PLINT >(val1);
21733  plscmap1n(arg1);
21734  _outv = octave_value();
21735  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21736  return _out;
21737 fail:
21738  return octave_value_list();
21739 }
21740 
21741 
21743  PLFLT arg1 ;
21744  PLFLT arg2 ;
21745  double val1 ;
21746  int ecode1 = 0 ;
21747  double val2 ;
21748  int ecode2 = 0 ;
21749  octave_value_list _out;
21750  octave_value_list *_outp=&_out;
21751  octave_value _outv;
21752 
21753  if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
21754  SWIG_fail;
21755  }
21756  ecode1 = SWIG_AsVal_double(args(0), &val1);
21757  if (!SWIG_IsOK(ecode1)) {
21758  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
21759  }
21760  arg1 = static_cast< PLFLT >(val1);
21761  ecode2 = SWIG_AsVal_double(args(1), &val2);
21762  if (!SWIG_IsOK(ecode2)) {
21763  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
21764  }
21765  arg2 = static_cast< PLFLT >(val2);
21766  plscmap1_range(arg1,arg2);
21767  _outv = octave_value();
21768  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21769  return _out;
21770 fail:
21771  return octave_value_list();
21772 }
21773 
21774 
21776  PLFLT *arg1 = (PLFLT *) 0 ;
21777  PLFLT *arg2 = (PLFLT *) 0 ;
21778  PLFLT temp1 ;
21779  int res1 = SWIG_TMPOBJ ;
21780  PLFLT temp2 ;
21781  int res2 = SWIG_TMPOBJ ;
21782  octave_value_list _out;
21783  octave_value_list *_outp=&_out;
21784  octave_value _outv;
21785 
21786  arg1 = &temp1;
21787  arg2 = &temp2;
21788  if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
21789  SWIG_fail;
21790  }
21791  plgcmap1_range(arg1,arg2);
21792  _outv = octave_value();
21793  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21794  if (SWIG_IsTmpObj(res1)) {
21795  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
21796  } else {
21797  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21798  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
21799  }
21800  if (SWIG_IsTmpObj(res2)) {
21801  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
21802  } else {
21803  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21804  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21805  }
21806  return _out;
21807 fail:
21808  return octave_value_list();
21809 }
21810 
21811 
21813  PLINT arg1 ;
21814  PLINT arg2 ;
21815  PLINT arg3 ;
21816  PLINT arg4 ;
21817  int val1 ;
21818  int ecode1 = 0 ;
21819  int val2 ;
21820  int ecode2 = 0 ;
21821  int val3 ;
21822  int ecode3 = 0 ;
21823  int val4 ;
21824  int ecode4 = 0 ;
21825  octave_value_list _out;
21826  octave_value_list *_outp=&_out;
21827  octave_value _outv;
21828 
21829  if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
21830  SWIG_fail;
21831  }
21832  ecode1 = SWIG_AsVal_int(args(0), &val1);
21833  if (!SWIG_IsOK(ecode1)) {
21834  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
21835  }
21836  arg1 = static_cast< PLINT >(val1);
21837  ecode2 = SWIG_AsVal_int(args(1), &val2);
21838  if (!SWIG_IsOK(ecode2)) {
21839  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
21840  }
21841  arg2 = static_cast< PLINT >(val2);
21842  ecode3 = SWIG_AsVal_int(args(2), &val3);
21843  if (!SWIG_IsOK(ecode3)) {
21844  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
21845  }
21846  arg3 = static_cast< PLINT >(val3);
21847  ecode4 = SWIG_AsVal_int(args(3), &val4);
21848  if (!SWIG_IsOK(ecode4)) {
21849  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
21850  }
21851  arg4 = static_cast< PLINT >(val4);
21852  plscol0(arg1,arg2,arg3,arg4);
21853  _outv = octave_value();
21854  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21855  return _out;
21856 fail:
21857  return octave_value_list();
21858 }
21859 
21860 
21862  PLINT arg1 ;
21863  PLINT arg2 ;
21864  PLINT arg3 ;
21865  PLINT arg4 ;
21866  PLFLT arg5 ;
21867  int val1 ;
21868  int ecode1 = 0 ;
21869  int val2 ;
21870  int ecode2 = 0 ;
21871  int val3 ;
21872  int ecode3 = 0 ;
21873  int val4 ;
21874  int ecode4 = 0 ;
21875  double val5 ;
21876  int ecode5 = 0 ;
21877  octave_value_list _out;
21878  octave_value_list *_outp=&_out;
21879  octave_value _outv;
21880 
21881  if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
21882  SWIG_fail;
21883  }
21884  ecode1 = SWIG_AsVal_int(args(0), &val1);
21885  if (!SWIG_IsOK(ecode1)) {
21886  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
21887  }
21888  arg1 = static_cast< PLINT >(val1);
21889  ecode2 = SWIG_AsVal_int(args(1), &val2);
21890  if (!SWIG_IsOK(ecode2)) {
21891  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
21892  }
21893  arg2 = static_cast< PLINT >(val2);
21894  ecode3 = SWIG_AsVal_int(args(2), &val3);
21895  if (!SWIG_IsOK(ecode3)) {
21896  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
21897  }
21898  arg3 = static_cast< PLINT >(val3);
21899  ecode4 = SWIG_AsVal_int(args(3), &val4);
21900  if (!SWIG_IsOK(ecode4)) {
21901  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
21902  }
21903  arg4 = static_cast< PLINT >(val4);
21904  ecode5 = SWIG_AsVal_double(args(4), &val5);
21905  if (!SWIG_IsOK(ecode5)) {
21906  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
21907  }
21908  arg5 = static_cast< PLFLT >(val5);
21909  plscol0a(arg1,arg2,arg3,arg4,arg5);
21910  _outv = octave_value();
21911  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21912  return _out;
21913 fail:
21914  return octave_value_list();
21915 }
21916 
21917 
21919  PLINT arg1 ;
21920  PLINT arg2 ;
21921  PLINT arg3 ;
21922  int val1 ;
21923  int ecode1 = 0 ;
21924  int val2 ;
21925  int ecode2 = 0 ;
21926  int val3 ;
21927  int ecode3 = 0 ;
21928  octave_value_list _out;
21929  octave_value_list *_outp=&_out;
21930  octave_value _outv;
21931 
21932  if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
21933  SWIG_fail;
21934  }
21935  ecode1 = SWIG_AsVal_int(args(0), &val1);
21936  if (!SWIG_IsOK(ecode1)) {
21937  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
21938  }
21939  arg1 = static_cast< PLINT >(val1);
21940  ecode2 = SWIG_AsVal_int(args(1), &val2);
21941  if (!SWIG_IsOK(ecode2)) {
21942  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
21943  }
21944  arg2 = static_cast< PLINT >(val2);
21945  ecode3 = SWIG_AsVal_int(args(2), &val3);
21946  if (!SWIG_IsOK(ecode3)) {
21947  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
21948  }
21949  arg3 = static_cast< PLINT >(val3);
21950  plscolbg(arg1,arg2,arg3);
21951  _outv = octave_value();
21952  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21953  return _out;
21954 fail:
21955  return octave_value_list();
21956 }
21957 
21958 
21960  PLINT arg1 ;
21961  PLINT arg2 ;
21962  PLINT arg3 ;
21963  PLFLT arg4 ;
21964  int val1 ;
21965  int ecode1 = 0 ;
21966  int val2 ;
21967  int ecode2 = 0 ;
21968  int val3 ;
21969  int ecode3 = 0 ;
21970  double val4 ;
21971  int ecode4 = 0 ;
21972  octave_value_list _out;
21973  octave_value_list *_outp=&_out;
21974  octave_value _outv;
21975 
21976  if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
21977  SWIG_fail;
21978  }
21979  ecode1 = SWIG_AsVal_int(args(0), &val1);
21980  if (!SWIG_IsOK(ecode1)) {
21981  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
21982  }
21983  arg1 = static_cast< PLINT >(val1);
21984  ecode2 = SWIG_AsVal_int(args(1), &val2);
21985  if (!SWIG_IsOK(ecode2)) {
21986  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
21987  }
21988  arg2 = static_cast< PLINT >(val2);
21989  ecode3 = SWIG_AsVal_int(args(2), &val3);
21990  if (!SWIG_IsOK(ecode3)) {
21991  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
21992  }
21993  arg3 = static_cast< PLINT >(val3);
21994  ecode4 = SWIG_AsVal_double(args(3), &val4);
21995  if (!SWIG_IsOK(ecode4)) {
21996  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
21997  }
21998  arg4 = static_cast< PLFLT >(val4);
21999  plscolbga(arg1,arg2,arg3,arg4);
22000  _outv = octave_value();
22001  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22002  return _out;
22003 fail:
22004  return octave_value_list();
22005 }
22006 
22007 
22009  PLINT arg1 ;
22010  int val1 ;
22011  int ecode1 = 0 ;
22012  octave_value_list _out;
22013  octave_value_list *_outp=&_out;
22014  octave_value _outv;
22015 
22016  if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
22017  SWIG_fail;
22018  }
22019  ecode1 = SWIG_AsVal_int(args(0), &val1);
22020  if (!SWIG_IsOK(ecode1)) {
22021  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
22022  }
22023  arg1 = static_cast< PLINT >(val1);
22024  plscolor(arg1);
22025  _outv = octave_value();
22026  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22027  return _out;
22028 fail:
22029  return octave_value_list();
22030 }
22031 
22032 
22034  PLINT arg1 ;
22035  int val1 ;
22036  int ecode1 = 0 ;
22037  octave_value_list _out;
22038  octave_value_list *_outp=&_out;
22039  octave_value _outv;
22040 
22041  if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
22042  SWIG_fail;
22043  }
22044  ecode1 = SWIG_AsVal_int(args(0), &val1);
22045  if (!SWIG_IsOK(ecode1)) {
22046  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
22047  }
22048  arg1 = static_cast< PLINT >(val1);
22049  plscompression(arg1);
22050  _outv = octave_value();
22051  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22052  return _out;
22053 fail:
22054  return octave_value_list();
22055 }
22056 
22057 
22059  char *arg1 = (char *) 0 ;
22060  int res1 ;
22061  char *buf1 = 0 ;
22062  int alloc1 = 0 ;
22063  octave_value_list _out;
22064  octave_value_list *_outp=&_out;
22065  octave_value _outv;
22066 
22067  if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
22068  SWIG_fail;
22069  }
22070  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22071  if (!SWIG_IsOK(res1)) {
22072  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
22073  }
22074  arg1 = reinterpret_cast< char * >(buf1);
22075  plsdev((char const *)arg1);
22076  _outv = octave_value();
22077  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22078  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22079  return _out;
22080 fail:
22081  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22082  return octave_value_list();
22083 }
22084 
22085 
22087  PLFLT arg1 ;
22088  PLFLT arg2 ;
22089  PLFLT arg3 ;
22090  PLFLT arg4 ;
22091  double val1 ;
22092  int ecode1 = 0 ;
22093  double val2 ;
22094  int ecode2 = 0 ;
22095  double val3 ;
22096  int ecode3 = 0 ;
22097  double val4 ;
22098  int ecode4 = 0 ;
22099  octave_value_list _out;
22100  octave_value_list *_outp=&_out;
22101  octave_value _outv;
22102 
22103  if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
22104  SWIG_fail;
22105  }
22106  ecode1 = SWIG_AsVal_double(args(0), &val1);
22107  if (!SWIG_IsOK(ecode1)) {
22108  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
22109  }
22110  arg1 = static_cast< PLFLT >(val1);
22111  ecode2 = SWIG_AsVal_double(args(1), &val2);
22112  if (!SWIG_IsOK(ecode2)) {
22113  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
22114  }
22115  arg2 = static_cast< PLFLT >(val2);
22116  ecode3 = SWIG_AsVal_double(args(2), &val3);
22117  if (!SWIG_IsOK(ecode3)) {
22118  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
22119  }
22120  arg3 = static_cast< PLFLT >(val3);
22121  ecode4 = SWIG_AsVal_double(args(3), &val4);
22122  if (!SWIG_IsOK(ecode4)) {
22123  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
22124  }
22125  arg4 = static_cast< PLFLT >(val4);
22126  plsdidev(arg1,arg2,arg3,arg4);
22127  _outv = octave_value();
22128  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22129  return _out;
22130 fail:
22131  return octave_value_list();
22132 }
22133 
22134 
22136  PLINT arg1 ;
22137  PLINT arg2 ;
22138  PLINT arg3 ;
22139  PLINT arg4 ;
22140  PLFLT arg5 ;
22141  PLFLT arg6 ;
22142  int val1 ;
22143  int ecode1 = 0 ;
22144  int val2 ;
22145  int ecode2 = 0 ;
22146  int val3 ;
22147  int ecode3 = 0 ;
22148  int val4 ;
22149  int ecode4 = 0 ;
22150  double val5 ;
22151  int ecode5 = 0 ;
22152  double val6 ;
22153  int ecode6 = 0 ;
22154  octave_value_list _out;
22155  octave_value_list *_outp=&_out;
22156  octave_value _outv;
22157 
22158  if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
22159  SWIG_fail;
22160  }
22161  ecode1 = SWIG_AsVal_int(args(0), &val1);
22162  if (!SWIG_IsOK(ecode1)) {
22163  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
22164  }
22165  arg1 = static_cast< PLINT >(val1);
22166  ecode2 = SWIG_AsVal_int(args(1), &val2);
22167  if (!SWIG_IsOK(ecode2)) {
22168  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
22169  }
22170  arg2 = static_cast< PLINT >(val2);
22171  ecode3 = SWIG_AsVal_int(args(2), &val3);
22172  if (!SWIG_IsOK(ecode3)) {
22173  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
22174  }
22175  arg3 = static_cast< PLINT >(val3);
22176  ecode4 = SWIG_AsVal_int(args(3), &val4);
22177  if (!SWIG_IsOK(ecode4)) {
22178  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
22179  }
22180  arg4 = static_cast< PLINT >(val4);
22181  ecode5 = SWIG_AsVal_double(args(4), &val5);
22182  if (!SWIG_IsOK(ecode5)) {
22183  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
22184  }
22185  arg5 = static_cast< PLFLT >(val5);
22186  ecode6 = SWIG_AsVal_double(args(5), &val6);
22187  if (!SWIG_IsOK(ecode6)) {
22188  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
22189  }
22190  arg6 = static_cast< PLFLT >(val6);
22191  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
22192  _outv = octave_value();
22193  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22194  return _out;
22195 fail:
22196  return octave_value_list();
22197 }
22198 
22199 
22201  PLFLT arg1 ;
22202  double val1 ;
22203  int ecode1 = 0 ;
22204  octave_value_list _out;
22205  octave_value_list *_outp=&_out;
22206  octave_value _outv;
22207 
22208  if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
22209  SWIG_fail;
22210  }
22211  ecode1 = SWIG_AsVal_double(args(0), &val1);
22212  if (!SWIG_IsOK(ecode1)) {
22213  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
22214  }
22215  arg1 = static_cast< PLFLT >(val1);
22216  plsdiori(arg1);
22217  _outv = octave_value();
22218  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22219  return _out;
22220 fail:
22221  return octave_value_list();
22222 }
22223 
22224 
22226  PLFLT arg1 ;
22227  PLFLT arg2 ;
22228  PLFLT arg3 ;
22229  PLFLT arg4 ;
22230  double val1 ;
22231  int ecode1 = 0 ;
22232  double val2 ;
22233  int ecode2 = 0 ;
22234  double val3 ;
22235  int ecode3 = 0 ;
22236  double val4 ;
22237  int ecode4 = 0 ;
22238  octave_value_list _out;
22239  octave_value_list *_outp=&_out;
22240  octave_value _outv;
22241 
22242  if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
22243  SWIG_fail;
22244  }
22245  ecode1 = SWIG_AsVal_double(args(0), &val1);
22246  if (!SWIG_IsOK(ecode1)) {
22247  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
22248  }
22249  arg1 = static_cast< PLFLT >(val1);
22250  ecode2 = SWIG_AsVal_double(args(1), &val2);
22251  if (!SWIG_IsOK(ecode2)) {
22252  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
22253  }
22254  arg2 = static_cast< PLFLT >(val2);
22255  ecode3 = SWIG_AsVal_double(args(2), &val3);
22256  if (!SWIG_IsOK(ecode3)) {
22257  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
22258  }
22259  arg3 = static_cast< PLFLT >(val3);
22260  ecode4 = SWIG_AsVal_double(args(3), &val4);
22261  if (!SWIG_IsOK(ecode4)) {
22262  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
22263  }
22264  arg4 = static_cast< PLFLT >(val4);
22265  plsdiplt(arg1,arg2,arg3,arg4);
22266  _outv = octave_value();
22267  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22268  return _out;
22269 fail:
22270  return octave_value_list();
22271 }
22272 
22273 
22275  PLFLT arg1 ;
22276  PLFLT arg2 ;
22277  PLFLT arg3 ;
22278  PLFLT arg4 ;
22279  double val1 ;
22280  int ecode1 = 0 ;
22281  double val2 ;
22282  int ecode2 = 0 ;
22283  double val3 ;
22284  int ecode3 = 0 ;
22285  double val4 ;
22286  int ecode4 = 0 ;
22287  octave_value_list _out;
22288  octave_value_list *_outp=&_out;
22289  octave_value _outv;
22290 
22291  if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
22292  SWIG_fail;
22293  }
22294  ecode1 = SWIG_AsVal_double(args(0), &val1);
22295  if (!SWIG_IsOK(ecode1)) {
22296  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
22297  }
22298  arg1 = static_cast< PLFLT >(val1);
22299  ecode2 = SWIG_AsVal_double(args(1), &val2);
22300  if (!SWIG_IsOK(ecode2)) {
22301  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
22302  }
22303  arg2 = static_cast< PLFLT >(val2);
22304  ecode3 = SWIG_AsVal_double(args(2), &val3);
22305  if (!SWIG_IsOK(ecode3)) {
22306  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
22307  }
22308  arg3 = static_cast< PLFLT >(val3);
22309  ecode4 = SWIG_AsVal_double(args(3), &val4);
22310  if (!SWIG_IsOK(ecode4)) {
22311  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
22312  }
22313  arg4 = static_cast< PLFLT >(val4);
22314  plsdiplz(arg1,arg2,arg3,arg4);
22315  _outv = octave_value();
22316  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22317  return _out;
22318 fail:
22319  return octave_value_list();
22320 }
22321 
22322 
22324  unsigned int arg1 ;
22325  unsigned int val1 ;
22326  int ecode1 = 0 ;
22327  octave_value_list _out;
22328  octave_value_list *_outp=&_out;
22329  octave_value _outv;
22330 
22331  if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
22332  SWIG_fail;
22333  }
22334  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
22335  if (!SWIG_IsOK(ecode1)) {
22336  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
22337  }
22338  arg1 = static_cast< unsigned int >(val1);
22339  plseed(arg1);
22340  _outv = octave_value();
22341  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22342  return _out;
22343 fail:
22344  return octave_value_list();
22345 }
22346 
22347 
22349  char arg1 ;
22350  char val1 ;
22351  int ecode1 = 0 ;
22352  octave_value_list _out;
22353  octave_value_list *_outp=&_out;
22354  octave_value _outv;
22355 
22356  if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
22357  SWIG_fail;
22358  }
22359  ecode1 = SWIG_AsVal_char(args(0), &val1);
22360  if (!SWIG_IsOK(ecode1)) {
22361  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
22362  }
22363  arg1 = static_cast< char >(val1);
22364  plsesc(arg1);
22365  _outv = octave_value();
22366  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22367  return _out;
22368 fail:
22369  return octave_value_list();
22370 }
22371 
22372 
22373 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
22374  char *arg1 = (char *) 0 ;
22375  char *arg2 = (char *) 0 ;
22376  int res1 ;
22377  char *buf1 = 0 ;
22378  int alloc1 = 0 ;
22379  int res2 ;
22380  char *buf2 = 0 ;
22381  int alloc2 = 0 ;
22382  octave_value_list _out;
22383  octave_value_list *_outp=&_out;
22384  octave_value _outv;
22385  PLINT result;
22386 
22387  if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
22388  SWIG_fail;
22389  }
22390  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22391  if (!SWIG_IsOK(res1)) {
22392  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
22393  }
22394  arg1 = reinterpret_cast< char * >(buf1);
22395  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22396  if (!SWIG_IsOK(res2)) {
22397  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
22398  }
22399  arg2 = reinterpret_cast< char * >(buf2);
22400  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
22401  _outv = SWIG_From_int(static_cast< int >(result));
22402  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22403  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22404  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22405  return _out;
22406 fail:
22407  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22408  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22409  return octave_value_list();
22410 }
22411 
22412 
22414  PLINT arg1 ;
22415  PLINT arg2 ;
22416  PLINT arg3 ;
22417  int val1 ;
22418  int ecode1 = 0 ;
22419  int val2 ;
22420  int ecode2 = 0 ;
22421  int val3 ;
22422  int ecode3 = 0 ;
22423  octave_value_list _out;
22424  octave_value_list *_outp=&_out;
22425  octave_value _outv;
22426 
22427  if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
22428  SWIG_fail;
22429  }
22430  ecode1 = SWIG_AsVal_int(args(0), &val1);
22431  if (!SWIG_IsOK(ecode1)) {
22432  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
22433  }
22434  arg1 = static_cast< PLINT >(val1);
22435  ecode2 = SWIG_AsVal_int(args(1), &val2);
22436  if (!SWIG_IsOK(ecode2)) {
22437  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
22438  }
22439  arg2 = static_cast< PLINT >(val2);
22440  ecode3 = SWIG_AsVal_int(args(2), &val3);
22441  if (!SWIG_IsOK(ecode3)) {
22442  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
22443  }
22444  arg3 = static_cast< PLINT >(val3);
22445  plsfam(arg1,arg2,arg3);
22446  _outv = octave_value();
22447  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22448  return _out;
22449 fail:
22450  return octave_value_list();
22451 }
22452 
22453 
22455  PLUNICODE arg1 ;
22456  unsigned int val1 ;
22457  int ecode1 = 0 ;
22458  octave_value_list _out;
22459  octave_value_list *_outp=&_out;
22460  octave_value _outv;
22461 
22462  if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
22463  SWIG_fail;
22464  }
22465  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
22466  if (!SWIG_IsOK(ecode1)) {
22467  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
22468  }
22469  arg1 = static_cast< PLUNICODE >(val1);
22470  plsfci(arg1);
22471  _outv = octave_value();
22472  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22473  return _out;
22474 fail:
22475  return octave_value_list();
22476 }
22477 
22478 
22480  char *arg1 = (char *) 0 ;
22481  int res1 ;
22482  char *buf1 = 0 ;
22483  int alloc1 = 0 ;
22484  octave_value_list _out;
22485  octave_value_list *_outp=&_out;
22486  octave_value _outv;
22487 
22488  if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
22489  SWIG_fail;
22490  }
22491  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22492  if (!SWIG_IsOK(res1)) {
22493  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
22494  }
22495  arg1 = reinterpret_cast< char * >(buf1);
22496  plsfnam((char const *)arg1);
22497  _outv = octave_value();
22498  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22499  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22500  return _out;
22501 fail:
22502  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22503  return octave_value_list();
22504 }
22505 
22506 
22508  PLINT arg1 ;
22509  PLINT arg2 ;
22510  PLINT arg3 ;
22511  int val1 ;
22512  int ecode1 = 0 ;
22513  int val2 ;
22514  int ecode2 = 0 ;
22515  int val3 ;
22516  int ecode3 = 0 ;
22517  octave_value_list _out;
22518  octave_value_list *_outp=&_out;
22519  octave_value _outv;
22520 
22521  if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
22522  SWIG_fail;
22523  }
22524  ecode1 = SWIG_AsVal_int(args(0), &val1);
22525  if (!SWIG_IsOK(ecode1)) {
22526  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
22527  }
22528  arg1 = static_cast< PLINT >(val1);
22529  ecode2 = SWIG_AsVal_int(args(1), &val2);
22530  if (!SWIG_IsOK(ecode2)) {
22531  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
22532  }
22533  arg2 = static_cast< PLINT >(val2);
22534  ecode3 = SWIG_AsVal_int(args(2), &val3);
22535  if (!SWIG_IsOK(ecode3)) {
22536  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
22537  }
22538  arg3 = static_cast< PLINT >(val3);
22539  plsfont(arg1,arg2,arg3);
22540  _outv = octave_value();
22541  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22542  return _out;
22543 fail:
22544  return octave_value_list();
22545 }
22546 
22547 
22549  label_func arg1 = (label_func) 0 ;
22550  PLPointer arg2 = (PLPointer) 0 ;
22551  int res2 ;
22552  octave_value_list _out;
22553  octave_value_list *_outp=&_out;
22554  octave_value _outv;
22555 
22556  if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
22557  SWIG_fail;
22558  }
22559  {
22560  octave_value obj = args(0);
22561 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
22562  if ( !obj.isempty() )
22563 #else
22564  if ( !obj.is_empty() )
22565 #endif
22566  {
22567  if ( obj.is_function_handle() || obj.is_inline_function() )
22568  {
22569  fcnLabelFunc = obj.function_value();
22570  }
22571  else if ( obj.is_string() )
22572  {
22573  nameLabelFunc = obj.string_value();
22574  fcnLabelFunc = NULL;
22575  }
22576  arg1 = labelfunc_octave;
22577  }
22578  else
22579  {
22580  arg1 = NULL;
22581  }
22582  }
22583  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
22584  if (!SWIG_IsOK(res2)) {
22585  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
22586  }
22587  plslabelfunc(arg1,arg2);
22588  _outv = octave_value();
22589  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22590  return _out;
22591 fail:
22592  return octave_value_list();
22593 }
22594 
22595 
22597  PLFLT arg1 ;
22598  PLFLT arg2 ;
22599  double val1 ;
22600  int ecode1 = 0 ;
22601  double val2 ;
22602  int ecode2 = 0 ;
22603  octave_value_list _out;
22604  octave_value_list *_outp=&_out;
22605  octave_value _outv;
22606 
22607  if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
22608  SWIG_fail;
22609  }
22610  ecode1 = SWIG_AsVal_double(args(0), &val1);
22611  if (!SWIG_IsOK(ecode1)) {
22612  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
22613  }
22614  arg1 = static_cast< PLFLT >(val1);
22615  ecode2 = SWIG_AsVal_double(args(1), &val2);
22616  if (!SWIG_IsOK(ecode2)) {
22617  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
22618  }
22619  arg2 = static_cast< PLFLT >(val2);
22620  plsmaj(arg1,arg2);
22621  _outv = octave_value();
22622  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22623  return _out;
22624 fail:
22625  return octave_value_list();
22626 }
22627 
22628 
22630  PLFLT arg1 ;
22631  PLFLT arg2 ;
22632  double val1 ;
22633  int ecode1 = 0 ;
22634  double val2 ;
22635  int ecode2 = 0 ;
22636  octave_value_list _out;
22637  octave_value_list *_outp=&_out;
22638  octave_value _outv;
22639 
22640  if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
22641  SWIG_fail;
22642  }
22643  ecode1 = SWIG_AsVal_double(args(0), &val1);
22644  if (!SWIG_IsOK(ecode1)) {
22645  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
22646  }
22647  arg1 = static_cast< PLFLT >(val1);
22648  ecode2 = SWIG_AsVal_double(args(1), &val2);
22649  if (!SWIG_IsOK(ecode2)) {
22650  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
22651  }
22652  arg2 = static_cast< PLFLT >(val2);
22653  plsmin(arg1,arg2);
22654  _outv = octave_value();
22655  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22656  return _out;
22657 fail:
22658  return octave_value_list();
22659 }
22660 
22661 
22663  PLINT arg1 ;
22664  int val1 ;
22665  int ecode1 = 0 ;
22666  octave_value_list _out;
22667  octave_value_list *_outp=&_out;
22668  octave_value _outv;
22669 
22670  if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
22671  SWIG_fail;
22672  }
22673  ecode1 = SWIG_AsVal_int(args(0), &val1);
22674  if (!SWIG_IsOK(ecode1)) {
22675  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
22676  }
22677  arg1 = static_cast< PLINT >(val1);
22678  plsori(arg1);
22679  _outv = octave_value();
22680  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22681  return _out;
22682 fail:
22683  return octave_value_list();
22684 }
22685 
22686 
22688  PLFLT arg1 ;
22689  PLFLT arg2 ;
22690  PLINT arg3 ;
22691  PLINT arg4 ;
22692  PLINT arg5 ;
22693  PLINT arg6 ;
22694  double val1 ;
22695  int ecode1 = 0 ;
22696  double val2 ;
22697  int ecode2 = 0 ;
22698  int val3 ;
22699  int ecode3 = 0 ;
22700  int val4 ;
22701  int ecode4 = 0 ;
22702  int val5 ;
22703  int ecode5 = 0 ;
22704  int val6 ;
22705  int ecode6 = 0 ;
22706  octave_value_list _out;
22707  octave_value_list *_outp=&_out;
22708  octave_value _outv;
22709 
22710  if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
22711  SWIG_fail;
22712  }
22713  ecode1 = SWIG_AsVal_double(args(0), &val1);
22714  if (!SWIG_IsOK(ecode1)) {
22715  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
22716  }
22717  arg1 = static_cast< PLFLT >(val1);
22718  ecode2 = SWIG_AsVal_double(args(1), &val2);
22719  if (!SWIG_IsOK(ecode2)) {
22720  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
22721  }
22722  arg2 = static_cast< PLFLT >(val2);
22723  ecode3 = SWIG_AsVal_int(args(2), &val3);
22724  if (!SWIG_IsOK(ecode3)) {
22725  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
22726  }
22727  arg3 = static_cast< PLINT >(val3);
22728  ecode4 = SWIG_AsVal_int(args(3), &val4);
22729  if (!SWIG_IsOK(ecode4)) {
22730  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
22731  }
22732  arg4 = static_cast< PLINT >(val4);
22733  ecode5 = SWIG_AsVal_int(args(4), &val5);
22734  if (!SWIG_IsOK(ecode5)) {
22735  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
22736  }
22737  arg5 = static_cast< PLINT >(val5);
22738  ecode6 = SWIG_AsVal_int(args(5), &val6);
22739  if (!SWIG_IsOK(ecode6)) {
22740  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
22741  }
22742  arg6 = static_cast< PLINT >(val6);
22743  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
22744  _outv = octave_value();
22745  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22746  return _out;
22747 fail:
22748  return octave_value_list();
22749 }
22750 
22751 
22753  char *arg1 = (char *) 0 ;
22754  int res1 ;
22755  char *buf1 = 0 ;
22756  int alloc1 = 0 ;
22757  octave_value_list _out;
22758  octave_value_list *_outp=&_out;
22759  octave_value _outv;
22760 
22761  if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
22762  SWIG_fail;
22763  }
22764  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22765  if (!SWIG_IsOK(res1)) {
22766  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
22767  }
22768  arg1 = reinterpret_cast< char * >(buf1);
22769  plspal0((char const *)arg1);
22770  _outv = octave_value();
22771  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22772  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22773  return _out;
22774 fail:
22775  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22776  return octave_value_list();
22777 }
22778 
22779 
22781  char *arg1 = (char *) 0 ;
22782  PLBOOL arg2 ;
22783  int res1 ;
22784  char *buf1 = 0 ;
22785  int alloc1 = 0 ;
22786  int val2 ;
22787  int ecode2 = 0 ;
22788  octave_value_list _out;
22789  octave_value_list *_outp=&_out;
22790  octave_value _outv;
22791 
22792  if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
22793  SWIG_fail;
22794  }
22795  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22796  if (!SWIG_IsOK(res1)) {
22797  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
22798  }
22799  arg1 = reinterpret_cast< char * >(buf1);
22800  ecode2 = SWIG_AsVal_int(args(1), &val2);
22801  if (!SWIG_IsOK(ecode2)) {
22802  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
22803  }
22804  arg2 = static_cast< PLBOOL >(val2);
22805  plspal1((char const *)arg1,arg2);
22806  _outv = octave_value();
22807  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22808  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22809  return _out;
22810 fail:
22811  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22812  return octave_value_list();
22813 }
22814 
22815 
22817  PLBOOL arg1 ;
22818  int val1 ;
22819  int ecode1 = 0 ;
22820  octave_value_list _out;
22821  octave_value_list *_outp=&_out;
22822  octave_value _outv;
22823 
22824  if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
22825  SWIG_fail;
22826  }
22827  ecode1 = SWIG_AsVal_int(args(0), &val1);
22828  if (!SWIG_IsOK(ecode1)) {
22829  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
22830  }
22831  arg1 = static_cast< PLBOOL >(val1);
22832  plspause(arg1);
22833  _outv = octave_value();
22834  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22835  return _out;
22836 fail:
22837  return octave_value_list();
22838 }
22839 
22840 
22842  PLINT arg1 ;
22843  int val1 ;
22844  int ecode1 = 0 ;
22845  octave_value_list _out;
22846  octave_value_list *_outp=&_out;
22847  octave_value _outv;
22848 
22849  if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
22850  SWIG_fail;
22851  }
22852  ecode1 = SWIG_AsVal_int(args(0), &val1);
22853  if (!SWIG_IsOK(ecode1)) {
22854  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
22855  }
22856  arg1 = static_cast< PLINT >(val1);
22857  plsstrm(arg1);
22858  _outv = octave_value();
22859  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22860  return _out;
22861 fail:
22862  return octave_value_list();
22863 }
22864 
22865 
22867  PLINT arg1 ;
22868  PLINT arg2 ;
22869  int val1 ;
22870  int ecode1 = 0 ;
22871  int val2 ;
22872  int ecode2 = 0 ;
22873  octave_value_list _out;
22874  octave_value_list *_outp=&_out;
22875  octave_value _outv;
22876 
22877  if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
22878  SWIG_fail;
22879  }
22880  ecode1 = SWIG_AsVal_int(args(0), &val1);
22881  if (!SWIG_IsOK(ecode1)) {
22882  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
22883  }
22884  arg1 = static_cast< PLINT >(val1);
22885  ecode2 = SWIG_AsVal_int(args(1), &val2);
22886  if (!SWIG_IsOK(ecode2)) {
22887  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
22888  }
22889  arg2 = static_cast< PLINT >(val2);
22890  plssub(arg1,arg2);
22891  _outv = octave_value();
22892  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22893  return _out;
22894 fail:
22895  return octave_value_list();
22896 }
22897 
22898 
22900  PLFLT arg1 ;
22901  PLFLT arg2 ;
22902  double val1 ;
22903  int ecode1 = 0 ;
22904  double val2 ;
22905  int ecode2 = 0 ;
22906  octave_value_list _out;
22907  octave_value_list *_outp=&_out;
22908  octave_value _outv;
22909 
22910  if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
22911  SWIG_fail;
22912  }
22913  ecode1 = SWIG_AsVal_double(args(0), &val1);
22914  if (!SWIG_IsOK(ecode1)) {
22915  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
22916  }
22917  arg1 = static_cast< PLFLT >(val1);
22918  ecode2 = SWIG_AsVal_double(args(1), &val2);
22919  if (!SWIG_IsOK(ecode2)) {
22920  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
22921  }
22922  arg2 = static_cast< PLFLT >(val2);
22923  plssym(arg1,arg2);
22924  _outv = octave_value();
22925  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22926  return _out;
22927 fail:
22928  return octave_value_list();
22929 }
22930 
22931 
22933  PLINT arg1 ;
22934  PLINT arg2 ;
22935  int val1 ;
22936  int ecode1 = 0 ;
22937  int val2 ;
22938  int ecode2 = 0 ;
22939  octave_value_list _out;
22940  octave_value_list *_outp=&_out;
22941  octave_value _outv;
22942 
22943  if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
22944  SWIG_fail;
22945  }
22946  ecode1 = SWIG_AsVal_int(args(0), &val1);
22947  if (!SWIG_IsOK(ecode1)) {
22948  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
22949  }
22950  arg1 = static_cast< PLINT >(val1);
22951  ecode2 = SWIG_AsVal_int(args(1), &val2);
22952  if (!SWIG_IsOK(ecode2)) {
22953  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
22954  }
22955  arg2 = static_cast< PLINT >(val2);
22956  plstar(arg1,arg2);
22957  _outv = octave_value();
22958  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22959  return _out;
22960 fail:
22961  return octave_value_list();
22962 }
22963 
22964 
22966  char *arg1 = (char *) 0 ;
22967  PLINT arg2 ;
22968  PLINT arg3 ;
22969  int res1 ;
22970  char *buf1 = 0 ;
22971  int alloc1 = 0 ;
22972  int val2 ;
22973  int ecode2 = 0 ;
22974  int val3 ;
22975  int ecode3 = 0 ;
22976  octave_value_list _out;
22977  octave_value_list *_outp=&_out;
22978  octave_value _outv;
22979 
22980  if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
22981  SWIG_fail;
22982  }
22983  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22984  if (!SWIG_IsOK(res1)) {
22985  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
22986  }
22987  arg1 = reinterpret_cast< char * >(buf1);
22988  ecode2 = SWIG_AsVal_int(args(1), &val2);
22989  if (!SWIG_IsOK(ecode2)) {
22990  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
22991  }
22992  arg2 = static_cast< PLINT >(val2);
22993  ecode3 = SWIG_AsVal_int(args(2), &val3);
22994  if (!SWIG_IsOK(ecode3)) {
22995  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
22996  }
22997  arg3 = static_cast< PLINT >(val3);
22998  plstart((char const *)arg1,arg2,arg3);
22999  _outv = octave_value();
23000  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23001  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23002  return _out;
23003 fail:
23004  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23005  return octave_value_list();
23006 }
23007 
23008 
23010  ct_func arg1 = (ct_func) 0 ;
23011  PLPointer arg2 = (PLPointer) 0 ;
23012  int res2 ;
23013  octave_value_list _out;
23014  octave_value_list *_outp=&_out;
23015  octave_value _outv;
23016 
23017  if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
23018  SWIG_fail;
23019  }
23020  {
23021  octave_value obj = args(0);
23022 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23023  if ( !obj.isempty() )
23024 #else
23025  if ( !obj.is_empty() )
23026 #endif
23027  {
23028  if ( obj.is_function_handle() || obj.is_inline_function() )
23029  {
23030  fcnCoordTrans = obj.function_value();
23031  }
23032  else if ( obj.is_string() )
23033  {
23034  nameCoordTrans = obj.string_value();
23035  fcnCoordTrans = NULL;
23036  }
23037  arg1 = ct_octave;
23038  }
23039  else
23040  {
23041  arg1 = NULL;
23042  }
23043  }
23044  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
23045  if (!SWIG_IsOK(res2)) {
23046  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
23047  }
23048  plstransform(arg1,arg2);
23049  _outv = octave_value();
23050  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23051  return _out;
23052 fail:
23053  return octave_value_list();
23054 }
23055 
23056 
23058  PLINT arg1 ;
23059  PLFLT *arg2 = (PLFLT *) 0 ;
23060  PLFLT *arg3 = (PLFLT *) 0 ;
23061  char *arg4 = (char *) 0 ;
23062  Matrix temp1 ;
23063  Matrix temp3 ;
23064  int res4 ;
23065  char *buf4 = 0 ;
23066  int alloc4 = 0 ;
23067  octave_value_list _out;
23068  octave_value_list *_outp=&_out;
23069  octave_value _outv;
23070 
23071  if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
23072  SWIG_fail;
23073  }
23074  {
23075  if ( _n_dims( args(0) ) > 1 )
23076  {
23077  error( "argument must be a scalar or vector" ); SWIG_fail;
23078  }
23079  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23080  temp1 = args(0).matrix_value();
23081  arg2 = &temp1( 0, 0 );
23082  }
23083  {
23084  if ( _n_dims( args(1) ) > 1 )
23085  {
23086  error( "argument must be a scalar or vector" ); SWIG_fail;
23087  }
23088  if ( _dim( args(1), 0 ) != Alen )
23089  {
23090  error( "argument vectors must be same length" ); SWIG_fail;
23091  }
23092  temp3 = args(1).matrix_value();
23093  arg3 = &temp3( 0, 0 );
23094  }
23095  res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
23096  if (!SWIG_IsOK(res4)) {
23097  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
23098  }
23099  arg4 = reinterpret_cast< char * >(buf4);
23100  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
23101  _outv = octave_value();
23102  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23103  {
23104 
23105  }
23106  {
23107 
23108  }
23109  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
23110  return _out;
23111 fail:
23112  {
23113 
23114  }
23115  {
23116 
23117  }
23118  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
23119  return octave_value_list();
23120 }
23121 
23122 
23124  PLINT arg1 ;
23125  PLFLT *arg2 = (PLFLT *) 0 ;
23126  PLFLT *arg3 = (PLFLT *) 0 ;
23127  PLFLT *arg4 = (PLFLT *) 0 ;
23128  char *arg5 = (char *) 0 ;
23129  Matrix temp1 ;
23130  Matrix temp3 ;
23131  Matrix temp4 ;
23132  int res5 ;
23133  char *buf5 = 0 ;
23134  int alloc5 = 0 ;
23135  octave_value_list _out;
23136  octave_value_list *_outp=&_out;
23137  octave_value _outv;
23138 
23139  if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
23140  SWIG_fail;
23141  }
23142  {
23143  if ( _n_dims( args(0) ) > 1 )
23144  {
23145  error( "argument must be a scalar or vector" ); SWIG_fail;
23146  }
23147  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23148  temp1 = args(0).matrix_value();
23149  arg2 = &temp1( 0, 0 );
23150  }
23151  {
23152  if ( _n_dims( args(1) ) > 1 )
23153  {
23154  error( "argument must be a scalar or vector" ); SWIG_fail;
23155  }
23156  if ( _dim( args(1), 0 ) != Alen )
23157  {
23158  error( "argument vectors must be same length" ); SWIG_fail;
23159  }
23160  temp3 = args(1).matrix_value();
23161  arg3 = &temp3( 0, 0 );
23162  }
23163  {
23164  if ( _n_dims( args(2) ) > 1 )
23165  {
23166  error( "argument must be a scalar or vector" ); SWIG_fail;
23167  }
23168  if ( _dim( args(2), 0 ) != Alen )
23169  {
23170  error( "argument vectors must be same length" ); SWIG_fail;
23171  }
23172  temp4 = args(2).matrix_value();
23173  arg4 = &temp4( 0, 0 );
23174  }
23175  res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
23176  if (!SWIG_IsOK(res5)) {
23177  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
23178  }
23179  arg5 = reinterpret_cast< char * >(buf5);
23180  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
23181  _outv = octave_value();
23182  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23183  {
23184 
23185  }
23186  {
23187 
23188  }
23189  {
23190 
23191  }
23192  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
23193  return _out;
23194 fail:
23195  {
23196 
23197  }
23198  {
23199 
23200  }
23201  {
23202 
23203  }
23204  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
23205  return octave_value_list();
23206 }
23207 
23208 
23210  PLINT arg1 ;
23211  PLINT arg2 ;
23212  PLFLT arg3 ;
23213  PLFLT arg4 ;
23214  int val1 ;
23215  int ecode1 = 0 ;
23216  int val2 ;
23217  int ecode2 = 0 ;
23218  double val3 ;
23219  int ecode3 = 0 ;
23220  double val4 ;
23221  int ecode4 = 0 ;
23222  octave_value_list _out;
23223  octave_value_list *_outp=&_out;
23224  octave_value _outv;
23225 
23226  if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
23227  SWIG_fail;
23228  }
23229  ecode1 = SWIG_AsVal_int(args(0), &val1);
23230  if (!SWIG_IsOK(ecode1)) {
23231  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
23232  }
23233  arg1 = static_cast< PLINT >(val1);
23234  ecode2 = SWIG_AsVal_int(args(1), &val2);
23235  if (!SWIG_IsOK(ecode2)) {
23236  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
23237  }
23238  arg2 = static_cast< PLINT >(val2);
23239  ecode3 = SWIG_AsVal_double(args(2), &val3);
23240  if (!SWIG_IsOK(ecode3)) {
23241  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
23242  }
23243  arg3 = static_cast< PLFLT >(val3);
23244  ecode4 = SWIG_AsVal_double(args(3), &val4);
23245  if (!SWIG_IsOK(ecode4)) {
23246  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
23247  }
23248  arg4 = static_cast< PLFLT >(val4);
23249  plstripa(arg1,arg2,arg3,arg4);
23250  _outv = octave_value();
23251  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23252  return _out;
23253 fail:
23254  return octave_value_list();
23255 }
23256 
23257 
23259  PLINT arg1 ;
23260  int val1 ;
23261  int ecode1 = 0 ;
23262  octave_value_list _out;
23263  octave_value_list *_outp=&_out;
23264  octave_value _outv;
23265 
23266  if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
23267  SWIG_fail;
23268  }
23269  ecode1 = SWIG_AsVal_int(args(0), &val1);
23270  if (!SWIG_IsOK(ecode1)) {
23271  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
23272  }
23273  arg1 = static_cast< PLINT >(val1);
23274  plstripd(arg1);
23275  _outv = octave_value();
23276  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23277  return _out;
23278 fail:
23279  return octave_value_list();
23280 }
23281 
23282 
23284  PLINT arg1 ;
23285  PLINT *arg2 = (PLINT *) 0 ;
23286  PLINT *arg3 = (PLINT *) 0 ;
23287  Matrix temp1 ;
23288  Matrix temp3 ;
23289  octave_value_list _out;
23290  octave_value_list *_outp=&_out;
23291  octave_value _outv;
23292 
23293  if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
23294  SWIG_fail;
23295  }
23296  {
23297  if ( _n_dims( args(0) ) > 1 )
23298  {
23299  error( "argument must be a scalar or vector" ); SWIG_fail;
23300  }
23301  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23302  arg2 = new PLINT[Alen];
23303  temp1 = args(0).matrix_value();
23304  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
23305  }
23306  {
23307  if ( _n_dims( args(1) ) > 1 )
23308  {
23309  error( "argument must be a scalar or vector" ); SWIG_fail;
23310  }
23311  if ( _dim( args(1), 0 ) != Alen )
23312  {
23313  error( "argument vectors must be same length" ); SWIG_fail;
23314  }
23315  temp3 = args(1).matrix_value();
23316  arg3 = new PLINT[Alen];
23317  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
23318  }
23319  plstyl(arg1,(int const *)arg2,(int const *)arg3);
23320  _outv = octave_value();
23321  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23322  {
23323  delete [] arg2;
23324  }
23325  {
23326  delete [] arg3;
23327  }
23328  return _out;
23329 fail:
23330  {
23331  delete [] arg2;
23332  }
23333  {
23334  delete [] arg3;
23335  }
23336  return octave_value_list();
23337 }
23338 
23339 
23341  PLFLT *arg1 = (PLFLT *) 0 ;
23342  PLFLT *arg2 = (PLFLT *) 0 ;
23343  PLINT arg3 ;
23344  PLBOOL arg4 ;
23345  Matrix temp1 ;
23346  Matrix temp2 ;
23347  int val4 ;
23348  int ecode4 = 0 ;
23349  octave_value_list _out;
23350  octave_value_list *_outp=&_out;
23351  octave_value _outv;
23352 
23353  if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
23354  SWIG_fail;
23355  }
23356  {
23357  if ( _n_dims( args(0) ) > 1 )
23358  {
23359  error( "argument must be a scalar or vector" ); SWIG_fail;
23360  }
23361 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23362  if ( !args(0).isempty() )
23363 #else
23364  if ( !args(0).is_empty() )
23365 #endif
23366  {
23367  Alen = (PLINT) ( _dim( args(0), 0 ) );
23368  temp1 = args(0).matrix_value();
23369  arg1 = &temp1( 0, 0 );
23370  }
23371  else
23372  {
23373  arg1 = NULL;
23374  Alen = 0;
23375  }
23376  }
23377  {
23378  if ( _n_dims( args(1) ) > 1 )
23379  {
23380  error( "argument must be a scalar or vector" ); SWIG_fail;
23381  }
23382 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23383  if ( !args(1).isempty() )
23384 #else
23385  if ( !args(1).is_empty() )
23386 #endif
23387  {
23388  if ( _dim( args(1), 0 ) != Alen )
23389  {
23390  error( "argument vectors must be same length" ); SWIG_fail;
23391  }
23392  temp2 = args(1).matrix_value();
23393  arg2 = &temp2( 0, 0 );
23394  arg3 = (PLINT) ( _dim( args(1), 0 ) );
23395  }
23396  else
23397  {
23398  arg2 = NULL;
23399  arg3 = 0;
23400  }
23401  }
23402  ecode4 = SWIG_AsVal_int(args(2), &val4);
23403  if (!SWIG_IsOK(ecode4)) {
23404  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
23405  }
23406  arg4 = static_cast< PLBOOL >(val4);
23407  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
23408  _outv = octave_value();
23409  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23410  {
23411 
23412  }
23413  {
23414 
23415  }
23416  return _out;
23417 fail:
23418  {
23419 
23420  }
23421  {
23422 
23423  }
23424  return octave_value_list();
23425 }
23426 
23427 
23429  PLFLT arg1 ;
23430  PLFLT arg2 ;
23431  PLFLT arg3 ;
23432  PLFLT arg4 ;
23433  double val1 ;
23434  int ecode1 = 0 ;
23435  double val2 ;
23436  int ecode2 = 0 ;
23437  double val3 ;
23438  int ecode3 = 0 ;
23439  double val4 ;
23440  int ecode4 = 0 ;
23441  octave_value_list _out;
23442  octave_value_list *_outp=&_out;
23443  octave_value _outv;
23444 
23445  if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
23446  SWIG_fail;
23447  }
23448  ecode1 = SWIG_AsVal_double(args(0), &val1);
23449  if (!SWIG_IsOK(ecode1)) {
23450  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
23451  }
23452  arg1 = static_cast< PLFLT >(val1);
23453  ecode2 = SWIG_AsVal_double(args(1), &val2);
23454  if (!SWIG_IsOK(ecode2)) {
23455  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
23456  }
23457  arg2 = static_cast< PLFLT >(val2);
23458  ecode3 = SWIG_AsVal_double(args(2), &val3);
23459  if (!SWIG_IsOK(ecode3)) {
23460  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
23461  }
23462  arg3 = static_cast< PLFLT >(val3);
23463  ecode4 = SWIG_AsVal_double(args(3), &val4);
23464  if (!SWIG_IsOK(ecode4)) {
23465  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
23466  }
23467  arg4 = static_cast< PLFLT >(val4);
23468  plsvpa(arg1,arg2,arg3,arg4);
23469  _outv = octave_value();
23470  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23471  return _out;
23472 fail:
23473  return octave_value_list();
23474 }
23475 
23476 
23478  PLINT arg1 ;
23479  PLINT arg2 ;
23480  int val1 ;
23481  int ecode1 = 0 ;
23482  int val2 ;
23483  int ecode2 = 0 ;
23484  octave_value_list _out;
23485  octave_value_list *_outp=&_out;
23486  octave_value _outv;
23487 
23488  if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
23489  SWIG_fail;
23490  }
23491  ecode1 = SWIG_AsVal_int(args(0), &val1);
23492  if (!SWIG_IsOK(ecode1)) {
23493  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
23494  }
23495  arg1 = static_cast< PLINT >(val1);
23496  ecode2 = SWIG_AsVal_int(args(1), &val2);
23497  if (!SWIG_IsOK(ecode2)) {
23498  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
23499  }
23500  arg2 = static_cast< PLINT >(val2);
23501  plsxax(arg1,arg2);
23502  _outv = octave_value();
23503  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23504  return _out;
23505 fail:
23506  return octave_value_list();
23507 }
23508 
23509 
23511  PLINT arg1 ;
23512  PLINT arg2 ;
23513  int val1 ;
23514  int ecode1 = 0 ;
23515  int val2 ;
23516  int ecode2 = 0 ;
23517  octave_value_list _out;
23518  octave_value_list *_outp=&_out;
23519  octave_value _outv;
23520 
23521  if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
23522  SWIG_fail;
23523  }
23524  ecode1 = SWIG_AsVal_int(args(0), &val1);
23525  if (!SWIG_IsOK(ecode1)) {
23526  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
23527  }
23528  arg1 = static_cast< PLINT >(val1);
23529  ecode2 = SWIG_AsVal_int(args(1), &val2);
23530  if (!SWIG_IsOK(ecode2)) {
23531  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
23532  }
23533  arg2 = static_cast< PLINT >(val2);
23534  plsyax(arg1,arg2);
23535  _outv = octave_value();
23536  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23537  return _out;
23538 fail:
23539  return octave_value_list();
23540 }
23541 
23542 
23544  PLINT arg1 ;
23545  PLFLT *arg2 = (PLFLT *) 0 ;
23546  PLFLT *arg3 = (PLFLT *) 0 ;
23547  PLINT arg4 ;
23548  Matrix temp1 ;
23549  Matrix temp3 ;
23550  int val4 ;
23551  int ecode4 = 0 ;
23552  octave_value_list _out;
23553  octave_value_list *_outp=&_out;
23554  octave_value _outv;
23555 
23556  if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
23557  SWIG_fail;
23558  }
23559  {
23560  if ( _n_dims( args(0) ) > 1 )
23561  {
23562  error( "argument must be a scalar or vector" ); SWIG_fail;
23563  }
23564  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23565  temp1 = args(0).matrix_value();
23566  arg2 = &temp1( 0, 0 );
23567  }
23568  {
23569  if ( _n_dims( args(1) ) > 1 )
23570  {
23571  error( "argument must be a scalar or vector" ); SWIG_fail;
23572  }
23573  if ( _dim( args(1), 0 ) != Alen )
23574  {
23575  error( "argument vectors must be same length" ); SWIG_fail;
23576  }
23577  temp3 = args(1).matrix_value();
23578  arg3 = &temp3( 0, 0 );
23579  }
23580  ecode4 = SWIG_AsVal_int(args(2), &val4);
23581  if (!SWIG_IsOK(ecode4)) {
23582  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
23583  }
23584  arg4 = static_cast< PLINT >(val4);
23585  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
23586  _outv = octave_value();
23587  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23588  {
23589 
23590  }
23591  {
23592 
23593  }
23594  return _out;
23595 fail:
23596  {
23597 
23598  }
23599  {
23600 
23601  }
23602  return octave_value_list();
23603 }
23604 
23605 
23607  PLINT arg1 ;
23608  PLINT arg2 ;
23609  int val1 ;
23610  int ecode1 = 0 ;
23611  int val2 ;
23612  int ecode2 = 0 ;
23613  octave_value_list _out;
23614  octave_value_list *_outp=&_out;
23615  octave_value _outv;
23616 
23617  if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
23618  SWIG_fail;
23619  }
23620  ecode1 = SWIG_AsVal_int(args(0), &val1);
23621  if (!SWIG_IsOK(ecode1)) {
23622  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
23623  }
23624  arg1 = static_cast< PLINT >(val1);
23625  ecode2 = SWIG_AsVal_int(args(1), &val2);
23626  if (!SWIG_IsOK(ecode2)) {
23627  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
23628  }
23629  arg2 = static_cast< PLINT >(val2);
23630  plszax(arg1,arg2);
23631  _outv = octave_value();
23632  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23633  return _out;
23634 fail:
23635  return octave_value_list();
23636 }
23637 
23638 
23640  octave_value_list _out;
23641  octave_value_list *_outp=&_out;
23642  octave_value _outv;
23643 
23644  if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
23645  SWIG_fail;
23646  }
23647  pltext();
23648  _outv = octave_value();
23649  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23650  return _out;
23651 fail:
23652  return octave_value_list();
23653 }
23654 
23655 
23657  char *arg1 = (char *) 0 ;
23658  int res1 ;
23659  char *buf1 = 0 ;
23660  int alloc1 = 0 ;
23661  octave_value_list _out;
23662  octave_value_list *_outp=&_out;
23663  octave_value _outv;
23664 
23665  if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
23666  SWIG_fail;
23667  }
23668  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23669  if (!SWIG_IsOK(res1)) {
23670  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
23671  }
23672  arg1 = reinterpret_cast< char * >(buf1);
23673  pltimefmt((char const *)arg1);
23674  _outv = octave_value();
23675  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23676  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23677  return _out;
23678 fail:
23679  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23680  return octave_value_list();
23681 }
23682 
23683 
23685  PLFLT arg1 ;
23686  double val1 ;
23687  int ecode1 = 0 ;
23688  octave_value_list _out;
23689  octave_value_list *_outp=&_out;
23690  octave_value _outv;
23691 
23692  if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
23693  SWIG_fail;
23694  }
23695  ecode1 = SWIG_AsVal_double(args(0), &val1);
23696  if (!SWIG_IsOK(ecode1)) {
23697  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
23698  }
23699  arg1 = static_cast< PLFLT >(val1);
23700  plvasp(arg1);
23701  _outv = octave_value();
23702  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23703  return _out;
23704 fail:
23705  return octave_value_list();
23706 }
23707 
23708 
23710  PLFLT arg1 ;
23711  PLFLT arg2 ;
23712  PLFLT arg3 ;
23713  PLFLT arg4 ;
23714  PLFLT arg5 ;
23715  double val1 ;
23716  int ecode1 = 0 ;
23717  double val2 ;
23718  int ecode2 = 0 ;
23719  double val3 ;
23720  int ecode3 = 0 ;
23721  double val4 ;
23722  int ecode4 = 0 ;
23723  double val5 ;
23724  int ecode5 = 0 ;
23725  octave_value_list _out;
23726  octave_value_list *_outp=&_out;
23727  octave_value _outv;
23728 
23729  if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
23730  SWIG_fail;
23731  }
23732  ecode1 = SWIG_AsVal_double(args(0), &val1);
23733  if (!SWIG_IsOK(ecode1)) {
23734  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
23735  }
23736  arg1 = static_cast< PLFLT >(val1);
23737  ecode2 = SWIG_AsVal_double(args(1), &val2);
23738  if (!SWIG_IsOK(ecode2)) {
23739  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
23740  }
23741  arg2 = static_cast< PLFLT >(val2);
23742  ecode3 = SWIG_AsVal_double(args(2), &val3);
23743  if (!SWIG_IsOK(ecode3)) {
23744  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
23745  }
23746  arg3 = static_cast< PLFLT >(val3);
23747  ecode4 = SWIG_AsVal_double(args(3), &val4);
23748  if (!SWIG_IsOK(ecode4)) {
23749  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
23750  }
23751  arg4 = static_cast< PLFLT >(val4);
23752  ecode5 = SWIG_AsVal_double(args(4), &val5);
23753  if (!SWIG_IsOK(ecode5)) {
23754  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
23755  }
23756  arg5 = static_cast< PLFLT >(val5);
23757  plvpas(arg1,arg2,arg3,arg4,arg5);
23758  _outv = octave_value();
23759  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23760  return _out;
23761 fail:
23762  return octave_value_list();
23763 }
23764 
23765 
23767  PLFLT arg1 ;
23768  PLFLT arg2 ;
23769  PLFLT arg3 ;
23770  PLFLT arg4 ;
23771  double val1 ;
23772  int ecode1 = 0 ;
23773  double val2 ;
23774  int ecode2 = 0 ;
23775  double val3 ;
23776  int ecode3 = 0 ;
23777  double val4 ;
23778  int ecode4 = 0 ;
23779  octave_value_list _out;
23780  octave_value_list *_outp=&_out;
23781  octave_value _outv;
23782 
23783  if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
23784  SWIG_fail;
23785  }
23786  ecode1 = SWIG_AsVal_double(args(0), &val1);
23787  if (!SWIG_IsOK(ecode1)) {
23788  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
23789  }
23790  arg1 = static_cast< PLFLT >(val1);
23791  ecode2 = SWIG_AsVal_double(args(1), &val2);
23792  if (!SWIG_IsOK(ecode2)) {
23793  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
23794  }
23795  arg2 = static_cast< PLFLT >(val2);
23796  ecode3 = SWIG_AsVal_double(args(2), &val3);
23797  if (!SWIG_IsOK(ecode3)) {
23798  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
23799  }
23800  arg3 = static_cast< PLFLT >(val3);
23801  ecode4 = SWIG_AsVal_double(args(3), &val4);
23802  if (!SWIG_IsOK(ecode4)) {
23803  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
23804  }
23805  arg4 = static_cast< PLFLT >(val4);
23806  plvpor(arg1,arg2,arg3,arg4);
23807  _outv = octave_value();
23808  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23809  return _out;
23810 fail:
23811  return octave_value_list();
23812 }
23813 
23814 
23816  octave_value_list _out;
23817  octave_value_list *_outp=&_out;
23818  octave_value _outv;
23819 
23820  if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
23821  SWIG_fail;
23822  }
23823  plvsta();
23824  _outv = octave_value();
23825  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23826  return _out;
23827 fail:
23828  return octave_value_list();
23829 }
23830 
23831 
23833  PLFLT arg1 ;
23834  PLFLT arg2 ;
23835  PLFLT arg3 ;
23836  PLFLT arg4 ;
23837  PLFLT arg5 ;
23838  PLFLT arg6 ;
23839  PLFLT arg7 ;
23840  PLFLT arg8 ;
23841  PLFLT arg9 ;
23842  PLFLT arg10 ;
23843  PLFLT arg11 ;
23844  double val1 ;
23845  int ecode1 = 0 ;
23846  double val2 ;
23847  int ecode2 = 0 ;
23848  double val3 ;
23849  int ecode3 = 0 ;
23850  double val4 ;
23851  int ecode4 = 0 ;
23852  double val5 ;
23853  int ecode5 = 0 ;
23854  double val6 ;
23855  int ecode6 = 0 ;
23856  double val7 ;
23857  int ecode7 = 0 ;
23858  double val8 ;
23859  int ecode8 = 0 ;
23860  double val9 ;
23861  int ecode9 = 0 ;
23862  double val10 ;
23863  int ecode10 = 0 ;
23864  double val11 ;
23865  int ecode11 = 0 ;
23866  octave_value_list _out;
23867  octave_value_list *_outp=&_out;
23868  octave_value _outv;
23869 
23870  if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
23871  SWIG_fail;
23872  }
23873  ecode1 = SWIG_AsVal_double(args(0), &val1);
23874  if (!SWIG_IsOK(ecode1)) {
23875  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
23876  }
23877  arg1 = static_cast< PLFLT >(val1);
23878  ecode2 = SWIG_AsVal_double(args(1), &val2);
23879  if (!SWIG_IsOK(ecode2)) {
23880  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
23881  }
23882  arg2 = static_cast< PLFLT >(val2);
23883  ecode3 = SWIG_AsVal_double(args(2), &val3);
23884  if (!SWIG_IsOK(ecode3)) {
23885  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
23886  }
23887  arg3 = static_cast< PLFLT >(val3);
23888  ecode4 = SWIG_AsVal_double(args(3), &val4);
23889  if (!SWIG_IsOK(ecode4)) {
23890  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
23891  }
23892  arg4 = static_cast< PLFLT >(val4);
23893  ecode5 = SWIG_AsVal_double(args(4), &val5);
23894  if (!SWIG_IsOK(ecode5)) {
23895  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
23896  }
23897  arg5 = static_cast< PLFLT >(val5);
23898  ecode6 = SWIG_AsVal_double(args(5), &val6);
23899  if (!SWIG_IsOK(ecode6)) {
23900  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
23901  }
23902  arg6 = static_cast< PLFLT >(val6);
23903  ecode7 = SWIG_AsVal_double(args(6), &val7);
23904  if (!SWIG_IsOK(ecode7)) {
23905  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
23906  }
23907  arg7 = static_cast< PLFLT >(val7);
23908  ecode8 = SWIG_AsVal_double(args(7), &val8);
23909  if (!SWIG_IsOK(ecode8)) {
23910  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
23911  }
23912  arg8 = static_cast< PLFLT >(val8);
23913  ecode9 = SWIG_AsVal_double(args(8), &val9);
23914  if (!SWIG_IsOK(ecode9)) {
23915  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
23916  }
23917  arg9 = static_cast< PLFLT >(val9);
23918  ecode10 = SWIG_AsVal_double(args(9), &val10);
23919  if (!SWIG_IsOK(ecode10)) {
23920  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
23921  }
23922  arg10 = static_cast< PLFLT >(val10);
23923  ecode11 = SWIG_AsVal_double(args(10), &val11);
23924  if (!SWIG_IsOK(ecode11)) {
23925  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
23926  }
23927  arg11 = static_cast< PLFLT >(val11);
23928  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
23929  _outv = octave_value();
23930  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23931  return _out;
23932 fail:
23933  return octave_value_list();
23934 }
23935 
23936 
23938  PLFLT arg1 ;
23939  double val1 ;
23940  int ecode1 = 0 ;
23941  octave_value_list _out;
23942  octave_value_list *_outp=&_out;
23943  octave_value _outv;
23944 
23945  if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
23946  SWIG_fail;
23947  }
23948  ecode1 = SWIG_AsVal_double(args(0), &val1);
23949  if (!SWIG_IsOK(ecode1)) {
23950  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
23951  }
23952  arg1 = static_cast< PLFLT >(val1);
23953  plwidth(arg1);
23954  _outv = octave_value();
23955  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23956  return _out;
23957 fail:
23958  return octave_value_list();
23959 }
23960 
23961 
23963  PLFLT arg1 ;
23964  PLFLT arg2 ;
23965  PLFLT arg3 ;
23966  PLFLT arg4 ;
23967  double val1 ;
23968  int ecode1 = 0 ;
23969  double val2 ;
23970  int ecode2 = 0 ;
23971  double val3 ;
23972  int ecode3 = 0 ;
23973  double val4 ;
23974  int ecode4 = 0 ;
23975  octave_value_list _out;
23976  octave_value_list *_outp=&_out;
23977  octave_value _outv;
23978 
23979  if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
23980  SWIG_fail;
23981  }
23982  ecode1 = SWIG_AsVal_double(args(0), &val1);
23983  if (!SWIG_IsOK(ecode1)) {
23984  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
23985  }
23986  arg1 = static_cast< PLFLT >(val1);
23987  ecode2 = SWIG_AsVal_double(args(1), &val2);
23988  if (!SWIG_IsOK(ecode2)) {
23989  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
23990  }
23991  arg2 = static_cast< PLFLT >(val2);
23992  ecode3 = SWIG_AsVal_double(args(2), &val3);
23993  if (!SWIG_IsOK(ecode3)) {
23994  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
23995  }
23996  arg3 = static_cast< PLFLT >(val3);
23997  ecode4 = SWIG_AsVal_double(args(3), &val4);
23998  if (!SWIG_IsOK(ecode4)) {
23999  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
24000  }
24001  arg4 = static_cast< PLFLT >(val4);
24002  plwind(arg1,arg2,arg3,arg4);
24003  _outv = octave_value();
24004  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24005  return _out;
24006 fail:
24007  return octave_value_list();
24008 }
24009 
24010 
24012  PLBOOL arg1 ;
24013  PLBOOL *arg2 = (PLBOOL *) 0 ;
24014  int val1 ;
24015  int ecode1 = 0 ;
24016  PLBOOL temp2 ;
24017  int res2 = SWIG_TMPOBJ ;
24018  octave_value_list _out;
24019  octave_value_list *_outp=&_out;
24020  octave_value _outv;
24021 
24022  arg2 = &temp2;
24023  if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
24024  SWIG_fail;
24025  }
24026  ecode1 = SWIG_AsVal_int(args(0), &val1);
24027  if (!SWIG_IsOK(ecode1)) {
24028  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
24029  }
24030  arg1 = static_cast< PLBOOL >(val1);
24031  plxormod(arg1,arg2);
24032  _outv = octave_value();
24033  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24034  if (SWIG_IsTmpObj(res2)) {
24035  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
24036  } else {
24037  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24038  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
24039  }
24040  return _out;
24041 fail:
24042  return octave_value_list();
24043 }
24044 
24045 
24047  mapform_func arg1 = (mapform_func) 0 ;
24048  char *arg2 = (char *) 0 ;
24049  PLFLT arg3 ;
24050  PLFLT arg4 ;
24051  PLFLT arg5 ;
24052  PLFLT arg6 ;
24053  int res2 ;
24054  char *buf2 = 0 ;
24055  int alloc2 = 0 ;
24056  double val3 ;
24057  int ecode3 = 0 ;
24058  double val4 ;
24059  int ecode4 = 0 ;
24060  double val5 ;
24061  int ecode5 = 0 ;
24062  double val6 ;
24063  int ecode6 = 0 ;
24064  octave_value_list _out;
24065  octave_value_list *_outp=&_out;
24066  octave_value _outv;
24067 
24068  if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
24069  SWIG_fail;
24070  }
24071  {
24072  octave_value obj = args(0);
24073 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24074  if ( !obj.isempty() )
24075 #else
24076  if ( !obj.is_empty() )
24077 #endif
24078  {
24079  if ( obj.is_function_handle() || obj.is_inline_function() )
24080  {
24081  fcnMapForm = obj.function_value();
24082  }
24083  else if ( obj.is_string() )
24084  {
24085  nameMapForm = obj.string_value();
24086  fcnMapForm = NULL;
24087  }
24088  arg1 = mapform_octave;
24089  }
24090  else
24091  {
24092  arg1 = NULL;
24093  }
24094  }
24095  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24096  if (!SWIG_IsOK(res2)) {
24097  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
24098  }
24099  arg2 = reinterpret_cast< char * >(buf2);
24100  ecode3 = SWIG_AsVal_double(args(2), &val3);
24101  if (!SWIG_IsOK(ecode3)) {
24102  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
24103  }
24104  arg3 = static_cast< PLFLT >(val3);
24105  ecode4 = SWIG_AsVal_double(args(3), &val4);
24106  if (!SWIG_IsOK(ecode4)) {
24107  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
24108  }
24109  arg4 = static_cast< PLFLT >(val4);
24110  ecode5 = SWIG_AsVal_double(args(4), &val5);
24111  if (!SWIG_IsOK(ecode5)) {
24112  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
24113  }
24114  arg5 = static_cast< PLFLT >(val5);
24115  ecode6 = SWIG_AsVal_double(args(5), &val6);
24116  if (!SWIG_IsOK(ecode6)) {
24117  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
24118  }
24119  arg6 = static_cast< PLFLT >(val6);
24120  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
24121  _outv = octave_value();
24122  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24123  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24124  return _out;
24125 fail:
24126  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24127  return octave_value_list();
24128 }
24129 
24130 
24132  mapform_func arg1 = (mapform_func) 0 ;
24133  char *arg2 = (char *) 0 ;
24134  PLFLT arg3 ;
24135  PLFLT arg4 ;
24136  PLFLT arg5 ;
24137  PLFLT arg6 ;
24138  PLINT *arg7 = (PLINT *) 0 ;
24139  PLINT arg8 ;
24140  int res2 ;
24141  char *buf2 = 0 ;
24142  int alloc2 = 0 ;
24143  double val3 ;
24144  int ecode3 = 0 ;
24145  double val4 ;
24146  int ecode4 = 0 ;
24147  double val5 ;
24148  int ecode5 = 0 ;
24149  double val6 ;
24150  int ecode6 = 0 ;
24151  Matrix temp7 ;
24152  octave_value_list _out;
24153  octave_value_list *_outp=&_out;
24154  octave_value _outv;
24155 
24156  if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
24157  SWIG_fail;
24158  }
24159  {
24160  octave_value obj = args(0);
24161 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24162  if ( !obj.isempty() )
24163 #else
24164  if ( !obj.is_empty() )
24165 #endif
24166  {
24167  if ( obj.is_function_handle() || obj.is_inline_function() )
24168  {
24169  fcnMapForm = obj.function_value();
24170  }
24171  else if ( obj.is_string() )
24172  {
24173  nameMapForm = obj.string_value();
24174  fcnMapForm = NULL;
24175  }
24176  arg1 = mapform_octave;
24177  }
24178  else
24179  {
24180  arg1 = NULL;
24181  }
24182  }
24183  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24184  if (!SWIG_IsOK(res2)) {
24185  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
24186  }
24187  arg2 = reinterpret_cast< char * >(buf2);
24188  ecode3 = SWIG_AsVal_double(args(2), &val3);
24189  if (!SWIG_IsOK(ecode3)) {
24190  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
24191  }
24192  arg3 = static_cast< PLFLT >(val3);
24193  ecode4 = SWIG_AsVal_double(args(3), &val4);
24194  if (!SWIG_IsOK(ecode4)) {
24195  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
24196  }
24197  arg4 = static_cast< PLFLT >(val4);
24198  ecode5 = SWIG_AsVal_double(args(4), &val5);
24199  if (!SWIG_IsOK(ecode5)) {
24200  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
24201  }
24202  arg5 = static_cast< PLFLT >(val5);
24203  ecode6 = SWIG_AsVal_double(args(5), &val6);
24204  if (!SWIG_IsOK(ecode6)) {
24205  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
24206  }
24207  arg6 = static_cast< PLFLT >(val6);
24208  {
24209  if ( _n_dims( args(6) ) > 1 )
24210  {
24211  error( "argument must be a scalar or vector" ); SWIG_fail;
24212  }
24213 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24214  if ( !args(6).isempty() )
24215 #else
24216  if ( !args(6).is_empty() )
24217 #endif
24218  {
24219  arg8 = (PLINT) ( _dim( args(6), 0 ) );
24220  temp7 = args(6).matrix_value();
24221  arg7 = new PLINT[arg8];
24222  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
24223  }
24224  else
24225  {
24226  arg7 = NULL;
24227  arg8 = 0;
24228  }
24229  }
24230  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
24231  _outv = octave_value();
24232  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24233  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24234  {
24235  delete [] arg7;
24236  }
24237  return _out;
24238 fail:
24239  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24240  {
24241  delete [] arg7;
24242  }
24243  return octave_value_list();
24244 }
24245 
24246 
24248  mapform_func arg1 = (mapform_func) 0 ;
24249  char *arg2 = (char *) 0 ;
24250  char *arg3 = (char *) 0 ;
24251  PLFLT arg4 ;
24252  PLFLT arg5 ;
24253  PLFLT arg6 ;
24254  PLFLT arg7 ;
24255  PLINT *arg8 = (PLINT *) 0 ;
24256  PLINT arg9 ;
24257  int res2 ;
24258  char *buf2 = 0 ;
24259  int alloc2 = 0 ;
24260  int res3 ;
24261  char *buf3 = 0 ;
24262  int alloc3 = 0 ;
24263  double val4 ;
24264  int ecode4 = 0 ;
24265  double val5 ;
24266  int ecode5 = 0 ;
24267  double val6 ;
24268  int ecode6 = 0 ;
24269  double val7 ;
24270  int ecode7 = 0 ;
24271  Matrix temp8 ;
24272  octave_value_list _out;
24273  octave_value_list *_outp=&_out;
24274  octave_value _outv;
24275 
24276  if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
24277  SWIG_fail;
24278  }
24279  {
24280  octave_value obj = args(0);
24281 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24282  if ( !obj.isempty() )
24283 #else
24284  if ( !obj.is_empty() )
24285 #endif
24286  {
24287  if ( obj.is_function_handle() || obj.is_inline_function() )
24288  {
24289  fcnMapForm = obj.function_value();
24290  }
24291  else if ( obj.is_string() )
24292  {
24293  nameMapForm = obj.string_value();
24294  fcnMapForm = NULL;
24295  }
24296  arg1 = mapform_octave;
24297  }
24298  else
24299  {
24300  arg1 = NULL;
24301  }
24302  }
24303  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24304  if (!SWIG_IsOK(res2)) {
24305  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
24306  }
24307  arg2 = reinterpret_cast< char * >(buf2);
24308  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
24309  if (!SWIG_IsOK(res3)) {
24310  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
24311  }
24312  arg3 = reinterpret_cast< char * >(buf3);
24313  ecode4 = SWIG_AsVal_double(args(3), &val4);
24314  if (!SWIG_IsOK(ecode4)) {
24315  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
24316  }
24317  arg4 = static_cast< PLFLT >(val4);
24318  ecode5 = SWIG_AsVal_double(args(4), &val5);
24319  if (!SWIG_IsOK(ecode5)) {
24320  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
24321  }
24322  arg5 = static_cast< PLFLT >(val5);
24323  ecode6 = SWIG_AsVal_double(args(5), &val6);
24324  if (!SWIG_IsOK(ecode6)) {
24325  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
24326  }
24327  arg6 = static_cast< PLFLT >(val6);
24328  ecode7 = SWIG_AsVal_double(args(6), &val7);
24329  if (!SWIG_IsOK(ecode7)) {
24330  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
24331  }
24332  arg7 = static_cast< PLFLT >(val7);
24333  {
24334  if ( _n_dims( args(7) ) > 1 )
24335  {
24336  error( "argument must be a scalar or vector" ); SWIG_fail;
24337  }
24338 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24339  if ( !args(7).isempty() )
24340 #else
24341  if ( !args(7).is_empty() )
24342 #endif
24343  {
24344  arg9 = (PLINT) ( _dim( args(7), 0 ) );
24345  temp8 = args(7).matrix_value();
24346  arg8 = new PLINT[arg9];
24347  _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
24348  }
24349  else
24350  {
24351  arg8 = NULL;
24352  arg9 = 0;
24353  }
24354  }
24355  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
24356  _outv = octave_value();
24357  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24358  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24359  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
24360  {
24361  delete [] arg8;
24362  }
24363  return _out;
24364 fail:
24365  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24366  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
24367  {
24368  delete [] arg8;
24369  }
24370  return octave_value_list();
24371 }
24372 
24373 
24375  mapform_func arg1 = (mapform_func) 0 ;
24376  char *arg2 = (char *) 0 ;
24377  PLFLT arg3 ;
24378  PLFLT arg4 ;
24379  PLFLT arg5 ;
24380  char *arg6 = (char *) 0 ;
24381  PLFLT arg7 ;
24382  PLFLT arg8 ;
24383  PLFLT arg9 ;
24384  PLFLT arg10 ;
24385  PLINT arg11 ;
24386  int res2 ;
24387  char *buf2 = 0 ;
24388  int alloc2 = 0 ;
24389  double val3 ;
24390  int ecode3 = 0 ;
24391  double val4 ;
24392  int ecode4 = 0 ;
24393  double val5 ;
24394  int ecode5 = 0 ;
24395  int res6 ;
24396  char *buf6 = 0 ;
24397  int alloc6 = 0 ;
24398  double val7 ;
24399  int ecode7 = 0 ;
24400  double val8 ;
24401  int ecode8 = 0 ;
24402  double val9 ;
24403  int ecode9 = 0 ;
24404  double val10 ;
24405  int ecode10 = 0 ;
24406  int val11 ;
24407  int ecode11 = 0 ;
24408  octave_value_list _out;
24409  octave_value_list *_outp=&_out;
24410  octave_value _outv;
24411 
24412  if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
24413  SWIG_fail;
24414  }
24415  {
24416  octave_value obj = args(0);
24417 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24418  if ( !obj.isempty() )
24419 #else
24420  if ( !obj.is_empty() )
24421 #endif
24422  {
24423  if ( obj.is_function_handle() || obj.is_inline_function() )
24424  {
24425  fcnMapForm = obj.function_value();
24426  }
24427  else if ( obj.is_string() )
24428  {
24429  nameMapForm = obj.string_value();
24430  fcnMapForm = NULL;
24431  }
24432  arg1 = mapform_octave;
24433  }
24434  else
24435  {
24436  arg1 = NULL;
24437  }
24438  }
24439  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24440  if (!SWIG_IsOK(res2)) {
24441  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
24442  }
24443  arg2 = reinterpret_cast< char * >(buf2);
24444  ecode3 = SWIG_AsVal_double(args(2), &val3);
24445  if (!SWIG_IsOK(ecode3)) {
24446  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
24447  }
24448  arg3 = static_cast< PLFLT >(val3);
24449  ecode4 = SWIG_AsVal_double(args(3), &val4);
24450  if (!SWIG_IsOK(ecode4)) {
24451  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
24452  }
24453  arg4 = static_cast< PLFLT >(val4);
24454  ecode5 = SWIG_AsVal_double(args(4), &val5);
24455  if (!SWIG_IsOK(ecode5)) {
24456  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
24457  }
24458  arg5 = static_cast< PLFLT >(val5);
24459  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
24460  if (!SWIG_IsOK(res6)) {
24461  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
24462  }
24463  arg6 = reinterpret_cast< char * >(buf6);
24464  ecode7 = SWIG_AsVal_double(args(6), &val7);
24465  if (!SWIG_IsOK(ecode7)) {
24466  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
24467  }
24468  arg7 = static_cast< PLFLT >(val7);
24469  ecode8 = SWIG_AsVal_double(args(7), &val8);
24470  if (!SWIG_IsOK(ecode8)) {
24471  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
24472  }
24473  arg8 = static_cast< PLFLT >(val8);
24474  ecode9 = SWIG_AsVal_double(args(8), &val9);
24475  if (!SWIG_IsOK(ecode9)) {
24476  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
24477  }
24478  arg9 = static_cast< PLFLT >(val9);
24479  ecode10 = SWIG_AsVal_double(args(9), &val10);
24480  if (!SWIG_IsOK(ecode10)) {
24481  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
24482  }
24483  arg10 = static_cast< PLFLT >(val10);
24484  ecode11 = SWIG_AsVal_int(args(10), &val11);
24485  if (!SWIG_IsOK(ecode11)) {
24486  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
24487  }
24488  arg11 = static_cast< PLINT >(val11);
24489  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
24490  _outv = octave_value();
24491  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24492  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24493  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
24494  return _out;
24495 fail:
24496  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24497  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
24498  return octave_value_list();
24499 }
24500 
24501 
24503  mapform_func arg1 = (mapform_func) 0 ;
24504  char *arg2 = (char *) 0 ;
24505  PLFLT arg3 ;
24506  PLFLT arg4 ;
24507  PLFLT arg5 ;
24508  PLFLT arg6 ;
24509  PLINT *arg7 = (PLINT *) 0 ;
24510  PLINT arg8 ;
24511  int res2 ;
24512  char *buf2 = 0 ;
24513  int alloc2 = 0 ;
24514  double val3 ;
24515  int ecode3 = 0 ;
24516  double val4 ;
24517  int ecode4 = 0 ;
24518  double val5 ;
24519  int ecode5 = 0 ;
24520  double val6 ;
24521  int ecode6 = 0 ;
24522  Matrix temp7 ;
24523  octave_value_list _out;
24524  octave_value_list *_outp=&_out;
24525  octave_value _outv;
24526 
24527  if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
24528  SWIG_fail;
24529  }
24530  {
24531  octave_value obj = args(0);
24532 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24533  if ( !obj.isempty() )
24534 #else
24535  if ( !obj.is_empty() )
24536 #endif
24537  {
24538  if ( obj.is_function_handle() || obj.is_inline_function() )
24539  {
24540  fcnMapForm = obj.function_value();
24541  }
24542  else if ( obj.is_string() )
24543  {
24544  nameMapForm = obj.string_value();
24545  fcnMapForm = NULL;
24546  }
24547  arg1 = mapform_octave;
24548  }
24549  else
24550  {
24551  arg1 = NULL;
24552  }
24553  }
24554  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24555  if (!SWIG_IsOK(res2)) {
24556  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
24557  }
24558  arg2 = reinterpret_cast< char * >(buf2);
24559  ecode3 = SWIG_AsVal_double(args(2), &val3);
24560  if (!SWIG_IsOK(ecode3)) {
24561  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
24562  }
24563  arg3 = static_cast< PLFLT >(val3);
24564  ecode4 = SWIG_AsVal_double(args(3), &val4);
24565  if (!SWIG_IsOK(ecode4)) {
24566  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
24567  }
24568  arg4 = static_cast< PLFLT >(val4);
24569  ecode5 = SWIG_AsVal_double(args(4), &val5);
24570  if (!SWIG_IsOK(ecode5)) {
24571  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
24572  }
24573  arg5 = static_cast< PLFLT >(val5);
24574  ecode6 = SWIG_AsVal_double(args(5), &val6);
24575  if (!SWIG_IsOK(ecode6)) {
24576  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
24577  }
24578  arg6 = static_cast< PLFLT >(val6);
24579  {
24580  if ( _n_dims( args(6) ) > 1 )
24581  {
24582  error( "argument must be a scalar or vector" ); SWIG_fail;
24583  }
24584 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24585  if ( !args(6).isempty() )
24586 #else
24587  if ( !args(6).is_empty() )
24588 #endif
24589  {
24590  arg8 = (PLINT) ( _dim( args(6), 0 ) );
24591  temp7 = args(6).matrix_value();
24592  arg7 = new PLINT[arg8];
24593  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
24594  }
24595  else
24596  {
24597  arg7 = NULL;
24598  arg8 = 0;
24599  }
24600  }
24601  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
24602  _outv = octave_value();
24603  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24604  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24605  {
24606  delete [] arg7;
24607  }
24608  return _out;
24609 fail:
24610  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24611  {
24612  delete [] arg7;
24613  }
24614  return octave_value_list();
24615 }
24616 
24617 
24619  mapform_func arg1 = (mapform_func) 0 ;
24620  PLFLT arg2 ;
24621  PLFLT arg3 ;
24622  PLFLT arg4 ;
24623  PLFLT arg5 ;
24624  PLFLT arg6 ;
24625  PLFLT arg7 ;
24626  double val2 ;
24627  int ecode2 = 0 ;
24628  double val3 ;
24629  int ecode3 = 0 ;
24630  double val4 ;
24631  int ecode4 = 0 ;
24632  double val5 ;
24633  int ecode5 = 0 ;
24634  double val6 ;
24635  int ecode6 = 0 ;
24636  double val7 ;
24637  int ecode7 = 0 ;
24638  octave_value_list _out;
24639  octave_value_list *_outp=&_out;
24640  octave_value _outv;
24641 
24642  if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
24643  SWIG_fail;
24644  }
24645  {
24646  octave_value obj = args(0);
24647 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24648  if ( !obj.isempty() )
24649 #else
24650  if ( !obj.is_empty() )
24651 #endif
24652  {
24653  if ( obj.is_function_handle() || obj.is_inline_function() )
24654  {
24655  fcnMapForm = obj.function_value();
24656  }
24657  else if ( obj.is_string() )
24658  {
24659  nameMapForm = obj.string_value();
24660  fcnMapForm = NULL;
24661  }
24662  arg1 = mapform_octave;
24663  }
24664  else
24665  {
24666  arg1 = NULL;
24667  }
24668  }
24669  ecode2 = SWIG_AsVal_double(args(1), &val2);
24670  if (!SWIG_IsOK(ecode2)) {
24671  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
24672  }
24673  arg2 = static_cast< PLFLT >(val2);
24674  ecode3 = SWIG_AsVal_double(args(2), &val3);
24675  if (!SWIG_IsOK(ecode3)) {
24676  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
24677  }
24678  arg3 = static_cast< PLFLT >(val3);
24679  ecode4 = SWIG_AsVal_double(args(3), &val4);
24680  if (!SWIG_IsOK(ecode4)) {
24681  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
24682  }
24683  arg4 = static_cast< PLFLT >(val4);
24684  ecode5 = SWIG_AsVal_double(args(4), &val5);
24685  if (!SWIG_IsOK(ecode5)) {
24686  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
24687  }
24688  arg5 = static_cast< PLFLT >(val5);
24689  ecode6 = SWIG_AsVal_double(args(5), &val6);
24690  if (!SWIG_IsOK(ecode6)) {
24691  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
24692  }
24693  arg6 = static_cast< PLFLT >(val6);
24694  ecode7 = SWIG_AsVal_double(args(6), &val7);
24695  if (!SWIG_IsOK(ecode7)) {
24696  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
24697  }
24698  arg7 = static_cast< PLFLT >(val7);
24699  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24700  _outv = octave_value();
24701  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24702  return _out;
24703 fail:
24704  return octave_value_list();
24705 }
24706 
24707 
24709  octave_value_list _out;
24710  octave_value_list *_outp=&_out;
24711  octave_value _outv;
24712 
24713  if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
24714  SWIG_fail;
24715  }
24716  plClearOpts();
24717  _outv = octave_value();
24718  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24719  return _out;
24720 fail:
24721  return octave_value_list();
24722 }
24723 
24724 
24726  octave_value_list _out;
24727  octave_value_list *_outp=&_out;
24728  octave_value _outv;
24729 
24730  if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
24731  SWIG_fail;
24732  }
24733  plResetOpts();
24734  _outv = octave_value();
24735  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24736  return _out;
24737 fail:
24738  return octave_value_list();
24739 }
24740 
24741 
24743  char *arg1 = (char *) 0 ;
24744  char *arg2 = (char *) 0 ;
24745  int res1 ;
24746  char *buf1 = 0 ;
24747  int alloc1 = 0 ;
24748  int res2 ;
24749  char *buf2 = 0 ;
24750  int alloc2 = 0 ;
24751  octave_value_list _out;
24752  octave_value_list *_outp=&_out;
24753  octave_value _outv;
24754 
24755  if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
24756  SWIG_fail;
24757  }
24758  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24759  if (!SWIG_IsOK(res1)) {
24760  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
24761  }
24762  arg1 = reinterpret_cast< char * >(buf1);
24763  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24764  if (!SWIG_IsOK(res2)) {
24765  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
24766  }
24767  arg2 = reinterpret_cast< char * >(buf2);
24768  plSetUsage((char const *)arg1,(char const *)arg2);
24769  _outv = octave_value();
24770  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24771  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24772  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24773  return _out;
24774 fail:
24775  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24776  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24777  return octave_value_list();
24778 }
24779 
24780 
24782  octave_value_list _out;
24783  octave_value_list *_outp=&_out;
24784  octave_value _outv;
24785 
24786  if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
24787  SWIG_fail;
24788  }
24789  plOptUsage();
24790  _outv = octave_value();
24791  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24792  return _out;
24793 fail:
24794  return octave_value_list();
24795 }
24796 
24797 
24798 
24799 static const struct swig_octave_member swig_globals[] = {
24800 {"testppchar",_wrap_testppchar,0,0,2,0},
24801 {"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
24802 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
24803 {"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
24804 {"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
24805 {"plcont0",_wrap_plcont0,0,0,2,0},
24806 {"plcont1",_wrap_plcont1,0,0,2,0},
24807 {"plcont2",_wrap_plcont2,0,0,2,0},
24808 {"plcont2p",_wrap_plcont2p,0,0,2,0},
24809 {"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
24810 {"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
24811 {"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
24812 {"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
24813 {"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
24814 {"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
24815 {"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
24816 {"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
24817 {"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
24818 {"plshade1",_wrap_plshade1,0,0,2,0},
24819 {"plshade2",_wrap_plshade2,0,0,2,0},
24820 {"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
24821 {"plshadesx",_wrap_plshadesx,0,0,2,0},
24822 {"plshades1",_wrap_plshades1,0,0,2,0},
24823 {"plshades2",_wrap_plshades2,0,0,2,0},
24824 {"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
24825 {"plvect1",_wrap_plvect1,0,0,2,0},
24826 {"plvect2",_wrap_plvect2,0,0,2,0},
24827 {"pplimage",_wrap_pplimage,0,0,2,0},
24828 {"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
24829 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
24830 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
24831 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
24832 {"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
24833 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
24834 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
24835 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
24836 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
24837 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
24838 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
24839 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
24840 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
24841 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
24842 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
24843 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
24844 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
24845 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
24846 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
24847 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
24848 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
24849 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
24850 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
24851 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
24852 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
24853 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
24854 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
24855 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
24856 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
24857 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
24858 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
24860 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
24861 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
24862 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
24863 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
24864 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
24865 {"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
24866 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
24867 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
24868 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
24869 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
24870 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
24871 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
24872 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
24873 {"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
24874 {"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
24875 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
24876 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
24877 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
24878 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
24879 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
24880 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
24881 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
24882 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
24883 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
24884 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
24885 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
24886 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
24887 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
24888 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
24889 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
24890 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
24891 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
24892 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
24893 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
24894 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
24895 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
24896 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
24897 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
24898 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
24899 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
24900 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
24901 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
24902 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
24903 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
24904 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
24905 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
24906 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
24907 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
24908 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
24909 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
24910 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
24911 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
24912 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
24913 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
24914 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
24915 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
24916 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
24917 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
24918 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
24919 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
24920 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
24921 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
24922 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
24923 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
24924 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
24925 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
24926 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
24927 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
24928 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
24929 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
24930 {"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
24931 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
24932 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
24933 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
24934 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
24935 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
24936 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
24937 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
24938 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
24939 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
24940 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
24941 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
24942 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
24943 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
24944 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
24945 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
24946 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
24947 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
24948 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
24949 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
24950 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
24951 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
24952 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
24953 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
24954 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
24955 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
24956 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
24957 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
24958 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
24959 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
24960 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
24961 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
24962 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
24963 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
24964 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
24965 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
24966 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
24967 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
24968 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
24969 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
24970 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
24971 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
24972 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
24973 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
24974 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
24975 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
24976 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
24977 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
24978 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
24979 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
24980 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
24981 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
24982 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
24983 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
24984 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
24985 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
24986 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
24987 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
24988 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
24989 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
24990 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
24991 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
24992 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
24993 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
24994 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
24995 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
24996 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
24997 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
24998 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
24999 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
25000 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
25001 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
25002 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
25003 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
25004 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
25005 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
25006 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
25007 {"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
25008 {"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
25009 {"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
25010 {"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
25011 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
25012 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
25013 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
25014 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
25015 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
25016 {0,0,0,0,0,0}
25017 };
25018 
25019 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
25020 
25021 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
25022 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
25023 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
25024 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};
25025 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};
25026 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};
25027 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
25028 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
25029 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
25030 
25033  &_swigt__p_char,
25038  &_swigt__p_int,
25041 };
25042 
25043 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
25044 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
25045 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
25049 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
25050 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
25051 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
25052 
25060  _swigc__p_int,
25063 };
25064 
25065 
25066 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
25067 
25068 /* -----------------------------------------------------------------------------
25069  * Type initialization:
25070  * This problem is tough by the requirement that no dynamic
25071  * memory is used. Also, since swig_type_info structures store pointers to
25072  * swig_cast_info structures and swig_cast_info structures store pointers back
25073  * to swig_type_info structures, we need some lookup code at initialization.
25074  * The idea is that swig generates all the structures that are needed.
25075  * The runtime then collects these partially filled structures.
25076  * The SWIG_InitializeModule function takes these initial arrays out of
25077  * swig_module, and does all the lookup, filling in the swig_module.types
25078  * array with the correct data and linking the correct swig_cast_info
25079  * structures together.
25080  *
25081  * The generated swig_type_info structures are assigned statically to an initial
25082  * array. We just loop through that array, and handle each type individually.
25083  * First we lookup if this type has been already loaded, and if so, use the
25084  * loaded structure instead of the generated one. Then we have to fill in the
25085  * cast linked list. The cast data is initially stored in something like a
25086  * two-dimensional array. Each row corresponds to a type (there are the same
25087  * number of rows as there are in the swig_type_initial array). Each entry in
25088  * a column is one of the swig_cast_info structures for that type.
25089  * The cast_initial array is actually an array of arrays, because each row has
25090  * a variable number of columns. So to actually build the cast linked list,
25091  * we find the array of casts associated with the type, and loop through it
25092  * adding the casts to the list. The one last trick we need to do is making
25093  * sure the type pointer in the swig_cast_info struct is correct.
25094  *
25095  * First off, we lookup the cast->type name to see if it is already loaded.
25096  * There are three cases to handle:
25097  * 1) If the cast->type has already been loaded AND the type we are adding
25098  * casting info to has not been loaded (it is in this module), THEN we
25099  * replace the cast->type pointer with the type pointer that has already
25100  * been loaded.
25101  * 2) If BOTH types (the one we are adding casting info to, and the
25102  * cast->type) are loaded, THEN the cast info has already been loaded by
25103  * the previous module so we just ignore it.
25104  * 3) Finally, if cast->type has not already been loaded, then we add that
25105  * swig_cast_info to the linked list (because the cast->type) pointer will
25106  * be correct.
25107  * ----------------------------------------------------------------------------- */
25108 
25109 #ifdef __cplusplus
25110 extern "C" {
25111 #if 0
25112 } /* c-mode */
25113 #endif
25114 #endif
25115 
25116 #if 0
25117 #define SWIGRUNTIME_DEBUG
25118 #endif
25119 
25120 
25121 SWIGRUNTIME void
25122 SWIG_InitializeModule(void *clientdata) {
25123  size_t i;
25124  swig_module_info *module_head, *iter;
25125  int init;
25126 
25127  /* check to see if the circular list has been setup, if not, set it up */
25128  if (swig_module.next==0) {
25129  /* Initialize the swig_module */
25133  init = 1;
25134  } else {
25135  init = 0;
25136  }
25137 
25138  /* Try and load any already created modules */
25139  module_head = SWIG_GetModule(clientdata);
25140  if (!module_head) {
25141  /* This is the first module loaded for this interpreter */
25142  /* so set the swig module into the interpreter */
25143  SWIG_SetModule(clientdata, &swig_module);
25144  } else {
25145  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
25146  iter=module_head;
25147  do {
25148  if (iter==&swig_module) {
25149  /* Our module is already in the list, so there's nothing more to do. */
25150  return;
25151  }
25152  iter=iter->next;
25153  } while (iter!= module_head);
25154 
25155  /* otherwise we must add our module into the list */
25156  swig_module.next = module_head->next;
25157  module_head->next = &swig_module;
25158  }
25159 
25160  /* When multiple interpreters are used, a module could have already been initialized in
25161  a different interpreter, but not yet have a pointer in this interpreter.
25162  In this case, we do not want to continue adding types... everything should be
25163  set up already */
25164  if (init == 0) return;
25165 
25166  /* Now work on filling in swig_module.types */
25167 #ifdef SWIGRUNTIME_DEBUG
25168  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
25169 #endif
25170  for (i = 0; i < swig_module.size; ++i) {
25171  swig_type_info *type = 0;
25172  swig_type_info *ret;
25174 
25175 #ifdef SWIGRUNTIME_DEBUG
25176  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
25177 #endif
25178 
25179  /* if there is another module already loaded */
25180  if (swig_module.next != &swig_module) {
25182  }
25183  if (type) {
25184  /* Overwrite clientdata field */
25185 #ifdef SWIGRUNTIME_DEBUG
25186  printf("SWIG_InitializeModule: found type %s\n", type->name);
25187 #endif
25190 #ifdef SWIGRUNTIME_DEBUG
25191  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
25192 #endif
25193  }
25194  } else {
25195  type = swig_module.type_initial[i];
25196  }
25197 
25198  /* Insert casting types */
25200  while (cast->type) {
25201 
25202  /* Don't need to add information already in the list */
25203  ret = 0;
25204 #ifdef SWIGRUNTIME_DEBUG
25205  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
25206 #endif
25207  if (swig_module.next != &swig_module) {
25209 #ifdef SWIGRUNTIME_DEBUG
25210  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
25211 #endif
25212  }
25213  if (ret) {
25214  if (type == swig_module.type_initial[i]) {
25215 #ifdef SWIGRUNTIME_DEBUG
25216  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
25217 #endif
25218  cast->type = ret;
25219  ret = 0;
25220  } else {
25221  /* Check for casting already in the list */
25222  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
25223 #ifdef SWIGRUNTIME_DEBUG
25224  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
25225 #endif
25226  if (!ocast) ret = 0;
25227  }
25228  }
25229 
25230  if (!ret) {
25231 #ifdef SWIGRUNTIME_DEBUG
25232  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
25233 #endif
25234  if (type->cast) {
25235  type->cast->prev = cast;
25236  cast->next = type->cast;
25237  }
25238  type->cast = cast;
25239  }
25240  cast++;
25241  }
25242  /* Set entry in modules->types array equal to the type */
25243  swig_module.types[i] = type;
25244  }
25245  swig_module.types[i] = 0;
25246 
25247 #ifdef SWIGRUNTIME_DEBUG
25248  printf("**** SWIG_InitializeModule: Cast List ******\n");
25249  for (i = 0; i < swig_module.size; ++i) {
25250  int j = 0;
25252  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
25253  while (cast->type) {
25254  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
25255  cast++;
25256  ++j;
25257  }
25258  printf("---- Total casts: %d\n",j);
25259  }
25260  printf("**** SWIG_InitializeModule: Cast List ******\n");
25261 #endif
25262 }
25263 
25264 /* This function will propagate the clientdata field of type to
25265 * any new swig_type_info structures that have been added into the list
25266 * of equivalent types. It is like calling
25267 * SWIG_TypeClientData(type, clientdata) a second time.
25268 */
25269 SWIGRUNTIME void
25271  size_t i;
25272  swig_cast_info *equiv;
25273  static int init_run = 0;
25274 
25275  if (init_run) return;
25276  init_run = 1;
25277 
25278  for (i = 0; i < swig_module.size; i++) {
25279  if (swig_module.types[i]->clientdata) {
25280  equiv = swig_module.types[i]->cast;
25281  while (equiv) {
25282  if (!equiv->converter) {
25283  if (equiv->type && !equiv->type->clientdata)
25285  }
25286  equiv = equiv->next;
25287  }
25288  }
25289  }
25290 }
25291 
25292 #ifdef __cplusplus
25293 #if 0
25294 { /* c-mode */
25295 #endif
25296 }
25297 #endif
25298 
25299 
25300 
25301 static bool SWIG_init_user(octave_swig_type* module_ns);
25302 
25304  bool retn = false;
25305  {
25306 #if SWIG_OCTAVE_PREREQ(4,2,0)
25307  octave::unwind_protect frame;
25308  frame.protect_var(discard_error_messages); discard_error_messages = true;
25309  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25310 #elif SWIG_OCTAVE_PREREQ(3,3,50)
25311  unwind_protect frame;
25312  frame.protect_var(error_state); error_state = 0;
25313  frame.protect_var(warning_state); warning_state = 0;
25314  frame.protect_var(discard_error_messages); discard_error_messages = true;
25315  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25316 #else
25317  unwind_protect::begin_frame("SWIG_Octave_LoadModule");
25318  unwind_protect_int(error_state); error_state = 0;
25319  unwind_protect_int(warning_state); warning_state = 0;
25320  unwind_protect_bool(discard_error_messages); discard_error_messages = true;
25321  unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
25322 #endif
25323 #if SWIG_OCTAVE_PREREQ(4,2,0)
25324  try {
25325 #if SWIG_OCTAVE_PREREQ(4,4,0)
25326  octave::feval(name, octave_value_list(), 0);
25327 #else
25328  feval(name, octave_value_list(), 0);
25329 #endif
25330  retn = true;
25331  } catch (octave::execution_exception&) { }
25332 #else
25333  feval(name, octave_value_list(), 0);
25334  retn = (error_state == 0);
25335 #endif
25336 #if !SWIG_OCTAVE_PREREQ(3,3,50)
25337  unwind_protect::run_frame("SWIG_Octave_LoadModule");
25338 #endif
25339  }
25340  if (!retn) {
25341  error(SWIG_name_d ": could not load module `%s'", name.c_str());
25342  }
25343  return retn;
25344 }
25345 
25346 SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
25347  bool retn = false;
25348  {
25349 #if SWIG_OCTAVE_PREREQ(4,2,0)
25350  octave::unwind_protect frame;
25351  frame.protect_var(discard_error_messages); discard_error_messages = true;
25352  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25353 #elif SWIG_OCTAVE_PREREQ(3,3,50)
25354  unwind_protect frame;
25355  frame.protect_var(error_state); error_state = 0;
25356  frame.protect_var(warning_state); warning_state = 0;
25357  frame.protect_var(discard_error_messages); discard_error_messages = true;
25358  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25359 #else
25360  unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
25361  unwind_protect_int(error_state); error_state = 0;
25362  unwind_protect_int(warning_state); warning_state = 0;
25363  unwind_protect_bool(discard_error_messages); discard_error_messages = true;
25364  unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
25365 #endif
25366  octave_value_list args;
25367  args.append(name);
25368  args.append(octloadfcn->fcn_file_name());
25369 #if SWIG_OCTAVE_PREREQ(4,2,0)
25370  try {
25371 #if SWIG_OCTAVE_PREREQ(4,4,0)
25372  octave::feval("autoload", args, 0);
25373 #else
25374  feval("autoload", args, 0);
25375 #endif
25376  retn = true;
25377  } catch (octave::execution_exception&) { }
25378 #else
25379  feval("autoload", args, 0);
25380  retn = (error_state == 0);
25381 #endif
25382 #if !SWIG_OCTAVE_PREREQ(3,3,50)
25383  unwind_protect::run_frame("SWIG_Octave_InstallFunction");
25384 #endif
25385  }
25386  if (!retn) {
25387  error(SWIG_name_d ": could not load function `%s'", name.c_str());
25388  }
25389  return retn;
25390 }
25391 
25392 static const char *const subclass_usage = "-*- texinfo -*- \n\
25393 @deftypefn {Loadable Function} {} subclass()\n\
25394 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
25395 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
25396 \n\
25397 See the SWIG manual for usage examples.\n\
25398 @end deftypefn";
25399 
25400 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
25402  for (int j = 0; j < args.length(); ++j) {
25403  if (args(j).type_id() == octave_swig_ref::static_type_id()) {
25404  octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
25405  octave_swig_type *ost = osr->get_ptr();
25406  if (!ost->is_owned()) {
25407  error("subclass: cannot subclass object not constructed on octave side");
25408  return octave_value_list();
25409  }
25410  top->merge(*ost);
25411  } else if (args(j).is_function_handle()) {
25412  top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
25413  } else if (args(j).is_string()) {
25414  if (j + 1 >= args.length()) {
25415  error("subclass: member assignments must be of string,value form");
25416  return octave_value_list();
25417  }
25418  top->assign(args(j).string_value(), args(j + 1));
25419  ++j;
25420  } else {
25421  error("subclass: invalid arguments to subclass()");
25422  return octave_value_list();
25423  }
25424  }
25425  return octave_value(Swig::swig_value_ref(top));
25426 }
25427 
25428 static const char *const swig_type_usage = "-*- texinfo -*- \n\
25429 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
25430 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
25431 @end deftypefn";
25432 
25433 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
25434  if (args.length() != 1) {
25435  error("swig_type: must be called with only a single object");
25436  return octave_value_list();
25437  }
25438  octave_swig_type *ost = Swig::swig_value_deref(args(0));
25439  if (!ost) {
25440  error("swig_type: object is not a swig_ref");
25441  return octave_value_list();
25442  }
25443  return octave_value(ost->swig_type_name());
25444 }
25445 
25446 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
25447 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
25448 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
25449 otherwise return `<unknown>'.\n\
25450 @end deftypefn";
25451 
25452 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
25453  if (args.length() != 1 || !args(0).is_string()) {
25454  error("swig_typequery: must be called with single string argument");
25455  return octave_value_list();
25456  }
25458  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
25459  if (!type)
25460  return octave_value("<unknown>");
25461  return octave_value(type->name);
25462 }
25463 
25464 static const char *const swig_this_usage = "-*- texinfo -*- \n\
25465 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
25466 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
25467 @end deftypefn";
25468 
25470  if (args.length() != 1) {
25471  error("swig_this: must be called with only a single object");
25472  return octave_value_list();
25473  }
25474  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
25475  return octave_value(octave_uint64(0));
25476  octave_swig_type *ost = Swig::swig_value_deref(args(0));
25477  if (!ost) {
25478  error("swig_this: object is not a swig_ref");
25479  return octave_value_list();
25480  }
25481  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
25482 }
25483 
25484 static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
25485 @deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
25486 Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
25487 @end deftypefn";
25488 
25489 DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
25490  if (args.length() != 3) {
25491  error("swig_octave_prereq: must be called with 3 arguments");
25492  return octave_value_list();
25493  }
25494  const int major = args(0).int_value();
25495  const int minor = args(1).int_value();
25496  const int patch = args(2).int_value();
25497  const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
25498  return octave_value(prereq);
25499 }
25500 
25501 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
25502 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
25503 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
25504 @end deftypefn";
25505 
25506 void __swig_atexit__(void) { ::_Exit(0); }
25507 
25509 
25510  static octave_swig_type* module_ns = 0;
25511 
25512  // workaround to prevent octave seg-faulting on exit: set Octave exit function
25513  // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
25514  // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
25515  // version 3.4.*, but reappeared in 4.2.*, so turn on for all versions after 3.2.*.
25516  // can be turned off with macro definition.
25517 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
25518 #if SWIG_OCTAVE_PREREQ(4,4,0)
25519  atexit(__swig_atexit__);
25520 #elif SWIG_OCTAVE_PREREQ(3,2,0)
25521  octave_exit = ::_Exit;
25522 #endif
25523 #endif
25524 
25525  // check for no input and output args
25526  if (args.length() != 0 || nargout != 0) {
25527  print_usage();
25528  return octave_value_list();
25529  }
25530 
25531  // create module on first function call
25532  if (!module_ns) {
25533 
25534  // workaround bug in octave where installing global variable of custom type and then
25535  // exiting without explicitly clearing the variable causes octave to segfault.
25536 #if SWIG_OCTAVE_PREREQ(3,2,0)
25537  octave_value_list eval_args;
25538  eval_args.append("base");
25539  eval_args.append("function __swig_atexit__; "
25540  " if mislocked() "
25541  " clear -all; "
25542  " else "
25543  " mlock(); "
25544  " endif; "
25545  "endfunction; "
25546  "__swig_atexit__; "
25547  "atexit(\"__swig_atexit__\", false); "
25548  "atexit(\"__swig_atexit__\")");
25549 #if SWIG_OCTAVE_PREREQ(4,4,0)
25550  octave::feval("evalin", eval_args, 0);
25551 #else
25552  feval("evalin", eval_args, 0);
25553 #endif
25554 #endif
25555 
25556 #if SWIG_OCTAVE_PREREQ(4,4,0)
25557  {
25558  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
25559  string_vector types = typeinfo.installed_type_names();
25560  bool register_octave_swig_ref = true;
25561  bool register_octave_swig_packed = true;
25562  bool register_octave_swig_bound_func = true;
25563  for (int i = 0; i < types.numel(); ++i) {
25564  if (types(i) == octave_swig_ref::static_type_name()) {
25565  register_octave_swig_ref = false;
25566  }
25567  if (types(i) == octave_swig_packed::static_type_name()) {
25568  register_octave_swig_packed = false;
25569  }
25570  if (types(i) == octave_swig_bound_func::static_type_name()) {
25571  register_octave_swig_bound_func = false;
25572  }
25573  }
25574  if (register_octave_swig_ref) {
25575  octave_swig_ref::register_type();
25576  }
25577  if (register_octave_swig_packed) {
25578  octave_swig_packed::register_type();
25579  }
25580  if (register_octave_swig_bound_func) {
25581  octave_swig_bound_func::register_type();
25582  }
25583  }
25584 #else
25585  octave_swig_ref::register_type();
25586  octave_swig_packed::register_type();
25587 #endif
25590 
25591 #if SWIG_OCTAVE_PREREQ(4,4,0)
25592  octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
25593  octave_function *me = stack.current();
25594 #else
25595  octave_function *me = octave_call_stack::current();
25596 #endif
25597 
25598  if (!SWIG_Octave_InstallFunction(me, "subclass")) {
25599  return octave_value_list();
25600  }
25601  if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
25602  return octave_value_list();
25603  }
25604  if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
25605  return octave_value_list();
25606  }
25607  if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
25608  return octave_value_list();
25609  }
25610  if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
25611  return octave_value_list();
25612  }
25613 
25614  octave_swig_type* cvar_ns=0;
25615  if (std::string(SWIG_global_name) != ".") {
25616  cvar_ns=new octave_swig_type;
25617  for (int j=0;swig_globals[j].name;++j)
25618  if (swig_globals[j].get_method)
25619  cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
25620  }
25621 
25622  module_ns=new octave_swig_type(0, 0, 0, true);
25623  if (std::string(SWIG_global_name) != ".") {
25624  module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
25625  }
25626  else {
25627  for (int j=0;swig_globals[j].name;++j)
25628  if (swig_globals[j].get_method)
25629  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
25630  }
25631  for (int j=0;swig_globals[j].name;++j)
25632  if (swig_globals[j].method)
25633  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
25634 
25635  // * need better solution here; swig_type -> octave_class mapping is
25636  // * really n-to-1, in some cases such as template partial spec, etc.
25637  // * see failing tests.
25638  for (int j=0;swig_types[j];++j)
25639  if (swig_types[j]->clientdata) {
25640  swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
25641  module_ns->assign(c->name,
25643  (new octave_swig_type(0,swig_types[j])));
25644  }
25645 
25646  if (!SWIG_init_user(module_ns)) {
25647  delete module_ns;
25648  module_ns=0;
25649  return octave_value_list();
25650  }
25651 
25652  SWIG_InstallOps(octave_swig_ref::static_type_id());
25653 
25655  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
25656  if (mb->second.first && mb->second.first->method) {
25657  if (!SWIG_Octave_InstallFunction(me, mb->first)) {
25658  return octave_value_list();
25659  }
25660  }
25661  }
25662 
25663 #if SWIG_OCTAVE_PREREQ(4,4,0)
25664  octave::interpreter::the_interpreter()->mlock();
25665 #elif SWIG_OCTAVE_PREREQ(3,2,0)
25666  mlock();
25667 #else
25668  mlock(me->name());
25669 #endif
25670 
25671  }
25672 
25674  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
25675  if (mb->second.second.is_defined()) {
25676  SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
25677  SWIG_Octave_LinkGlobalValue(mb->first);
25678  }
25679  }
25680 
25683 
25684  return octave_value_list();
25685 
25686 }
25687 
25688 
25689 static bool SWIG_init_user(octave_swig_type* module_ns)
25690 {
25691  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
25692  SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
25693  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
25694  SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
25695  SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
25696  SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
25697  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
25698  SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
25699  SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
25700  SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
25701  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
25702  SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
25703  SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
25704  SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
25705  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
25706  SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
25707  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
25708  SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
25709  SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
25710  SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
25711  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
25712  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
25713  SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
25714  SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
25715  SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
25716  SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
25717  SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
25718  SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
25719  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
25720  SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
25721  SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
25722  SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
25723  SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
25724  SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
25725  SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
25726  SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
25727  SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
25728  SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
25729  SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
25730  SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
25731  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
25732  SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
25733  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
25734  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
25735  SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
25736  SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
25737  SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
25738  SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
25739  SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
25740  SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
25741  SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
25742  SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
25743  SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
25744  SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
25745  SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
25746  SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
25747  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
25748  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
25749  SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
25750  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
25751  SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
25752  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
25753  SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
25754  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
25755  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
25756  SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
25757  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
25758  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
25759  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
25760  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
25761  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
25762  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
25763  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
25764  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
25765  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
25766  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
25767  SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
25768  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
25769  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
25770  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
25771  SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
25772  SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
25773  SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
25774  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
25775  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
25776  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
25777  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
25778  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
25779  SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
25780  SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
25781  SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
25782  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
25783  SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
25784  SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
25785  SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
25786  SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
25787  SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
25788  SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
25789  SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
25790  SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
25791  SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
25792  SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
25793  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
25794  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
25795  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
25796  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
25797  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
25798  SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
25799  SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
25800  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
25801  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
25802  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
25803  SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
25804  SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
25805  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
25806  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
25807  SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
25808  SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
25809  SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
25810  SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
25811  SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
25812  SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
25813  SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
25814  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
25815  SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
25816  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
25817  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
25818  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
25819  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
25820  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
25821  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
25822  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
25823  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
25824  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
25825  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
25826  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
25827  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
25828  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
25829  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
25830  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
25831  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
25832  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
25833  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
25834  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
25835  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
25836  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
25837  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
25838  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
25839  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
25840  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
25841  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
25842  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
25843  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
25844  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
25845  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
25846  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
25847  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
25848  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
25849  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
25850  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
25851  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
25852  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
25853  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
25854  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
25855  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
25856  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
25857  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
25858  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
25859  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
25860  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
25861  SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
25862  SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
25863  SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
25864  SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
25865  SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
25866  SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
25867  SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
25868  return true;
25869 }
25870 
static const char * _wrap_pljoin_texinfo
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plstripc(PLINT *id, PLCHAR_VECTOR xspec, PLCHAR_VECTOR yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLINT y_ascl, PLINT acc, PLINT colbox, PLINT collab, PLINT_VECTOR colline, PLINT_VECTOR styline, PLCHAR_MATRIX legline, PLCHAR_VECTOR labx, PLCHAR_VECTOR laby, PLCHAR_VECTOR labtop)
Definition: plstripc.c:66
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_IsOK(r)
static const swig_type_info * swig_PLGraphicsIn_base[]
static swig_cast_info _swigc__p_int[]
std::string nameMapForm
static const char * _wrap_pladv_texinfo
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsfam
Definition: plplot.h:805
octave_base_value * clone() const
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
def plClearOpts
Definition: plplotc.py:8391
octave_base_value * clone() const
#define plw3d
Definition: plplot.h:851
void merge(octave_swig_type &rhs)
#define swigreg_binary_op(name)
void load_members(member_map &out) const
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
static const char * _wrap_plimagefr_texinfo
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CheckState(r)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define swig_binary_op(name)
virtual bool is_map() const
octave_base_value * empty_clone() const
static const char * name
Definition: tkMain.c:135
#define plpath
Definition: plplot.h:750
static const char * _wrap_plgriddata_texinfo
static const char * _wrap_pl_setcontlabelformat_texinfo
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
void *(* swig_converter_func)(void *, int *)
SWIGINTERNINLINE octave_value SWIG_From_double(double value)
static bool SWIG_init_user(octave_swig_type *module_ns)
static const char * _wrap_plsmin_texinfo
integer(kind=private_plint), parameter, private maxlen
Definition: plplot.f90:48
octave_function * fcnLabelFunc
static const char * _wrap_plsyax_texinfo
#define plgxax
Definition: plplot.h:737
static const char * swig_PLGraphicsIn_base_names[]
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsstrm
Definition: plplot.h:824
static const char *const swig_typequery_usage
SWIGINTERN PyObject * _wrap_plot3dc(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)
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual std::string string_value(bool force=false) const
octave_value operator*() const
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
void c_plmeshc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:150
static const char * _wrap_plschr_texinfo
#define plspage
Definition: plplot.h:820
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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:849
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plot3dcl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plszax_texinfo
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_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_OverflowError
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plmtex3
Definition: plplot.h:763
#define plerry
Definition: plplot.h:704
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_GetModule(clientdata)
#define plsyax
Definition: plplot.h:841
#define SWIG_OK
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual double scalar_value(bool frc_str_conv=false) const
static const char * _wrap_pltimefmt_texinfo
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plschr
Definition: plplot.h:779
#define plsdev
Definition: plplot.h:795
static const char * _wrap_plmapline_texinfo
static const char * _wrap_plsdimap_texinfo
static const char * _wrap_plsfci_texinfo
static const char * _wrap_plinit_texinfo
static const char * _wrap_plstripa_texinfo
#define plgdev
Definition: plplot.h:718
PLFLT dX
Definition: plplot.h:446
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual type_conv_info numeric_conversion_function(void) const
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_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgcmap1_range_texinfo
void c_plot3dcl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
Definition: plot3d.c:921
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs)
#define SWIG_RUNTIME_VERSION
static const char * _wrap_plsori_texinfo
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pllegend
Definition: plplot.h:747
const char * help_text() const
static const char * _wrap_plstransform_texinfo
#define SWIG_POINTER_OWN
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
static const char * _wrap_plscmap1a_texinfo
virtual bool save_ascii(std::ostream &os)
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
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
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plshade
Definition: plplot.h:809
#define plscompression
Definition: plplot.h:794
#define plarc
Definition: plplot.h:682
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
std::string nameLabelFunc
static const char * _wrap_plstripd_texinfo
int cast(void **vptr, swig_type_info *type, int *_own, int flags)
PLUINT PLUNICODE
Definition: plplot.h:196
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
virtual bool is_string() const
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
static const char * _wrap_plmtex3_texinfo
octave_base_value * empty_clone() const
#define plot3dc
Definition: plplot.h:765
static const char * _wrap_plpoin_texinfo
SWIGRUNTIME void SWIG_PropagateClientData(void)
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plot3dcl
Definition: plplot.h:766
static const char *const swig_octave_prereq_usage
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pllsty
Definition: plplot.h:752
#define SWIG_SystemError
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref")
#define plsmin
Definition: plplot.h:818
#define plwind
Definition: plplot.h:853
#define plclear
Definition: plplot.h:690
#define plfill
Definition: plplot.h:706
#define plconfigtime
Definition: plplot.h:694
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_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsurf3dl
Definition: plplot.h:837
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plpoin3_texinfo
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_swig_type * get_ptr() const
virtual bool is_object() const
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:594
#define plbtime
Definition: plplot.h:688
void c_plsurf3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:326
static const char * _wrap_plmesh_texinfo
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pl_setcontlabelparam
Definition: plplot.h:680
#define SWIGTYPE_p_p_char
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscolbg
Definition: plplot.h:791
swig_dycast_func dcast
static swig_type_info _swigt__p_double
struct swig_cast_info * cast
static const char * _wrap_plsstrm_texinfo
void print(std::ostream &os, bool pr_as_read_syntax=false) const
#define plfont
Definition: plplot.h:709
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
#define plstyl
Definition: plplot.h:835
static const char * _wrap_plgspa_texinfo
#define PL_MAXKEY
Definition: plplot.h:412
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
#define SWIG_OLDOBJ
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plpoly3
Definition: plplot.h:771
#define SWIGINTERN
#define plimage
Definition: plplot.h:742
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
swig_type_info * type
#define SWIG_TypeQuery(name)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(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:710
static const char * _wrap_plenv0_texinfo
void print(std::ostream &os, bool pr_as_read_syntax=false) const
#define plscolbga
Definition: plplot.h:792
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plbin
Definition: plplot.h:684
PLINT plTranslateCursor(PLGraphicsIn *plg)
Definition: plpage.c:259
#define plsdiori
Definition: plplot.h:798
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plpsty_texinfo
virtual Octave_map map_value() const
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void c_plot3dc(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel)
Definition: plot3d.c:883
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
#define plparseopts
Definition: plplot.h:767
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:639
#define plsym
Definition: plplot.h:842
#define plscmap1
Definition: plplot.h:783
std::map< std::string, member_value_pair > member_map
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plinit
Definition: plplot.h:744
#define plctime
Definition: plplot.h:697
#define pltimefmt
Definition: plplot.h:845
#define plscmap1n
Definition: plplot.h:787
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgfont_texinfo
#define plbop
Definition: plplot.h:685
void c_plot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
Definition: plot3d.c:860
void c_plsurf3dl(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLFLT_VECTOR clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, PLINT_VECTOR indexymin, PLINT_VECTOR indexymax)
Definition: plot3d.c:389
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
def pltr0
Definition: plplotc.py:101
static int error
Definition: plcont.c:61
static swig_type_info _swigt__p_p_char
#define plsdiplt
Definition: plplot.h:799
struct swig_module_info swig_module_info
#define plsvect
Definition: plplot.h:838
#define plscmap1a
Definition: plplot.h:784
#define plssub
Definition: plplot.h:825
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
Definition: plot3d.c:118
static const char * _wrap_plcont_texinfo
member_map::const_iterator swig_member_const_iterator
static const char * _wrap_plstring_texinfo
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_ConvertPtr(obj, pptr, type, flags)
void * PLPointer
Definition: plplot.h:204
#define plspal1
Definition: plplot.h:822
#define plsetopt
Definition: plplot.h:804
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plmeshc
Definition: plplot.h:760
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plbox3_texinfo
#define plgcompression
Definition: plplot.h:717
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_name
#define plszax
Definition: plplot.h:843
#define plvsta
Definition: plplot.h:850
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdidev_texinfo
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static int _n_dims(const octave_value &o_obj)
#define plgpage
Definition: plplot.h:728
#define plaxes
Definition: plplot.h:683
#define plsori
Definition: plplot.h:819
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_f_int_p_double_p_double__void
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
#define plgdiplt
Definition: plplot.h:721
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char *const SWIG_name_usage
#define plscmap0a
Definition: plplot.h:781
#define SWIG_TypeError
PLINT ny
Definition: plplot.h:525
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
static int my_plGetCursor(int *state, int *keysym, int *button, char *string, int *pX, int *pY, PLFLT *dX, PLFLT *dY, PLFLT *wX, PLFLT *wY, int *subwin)
#define plfamadv
Definition: plplot.h:705
static const char * _wrap_plarc_texinfo
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plwind_texinfo
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
#define plend
Definition: plplot.h:698
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdiori_texinfo
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
alias _N2 PLGraphicsIn
Definition: plplot.d:1262
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plstring3_texinfo
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsfont_texinfo
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_double[]
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
void my_plcont2p(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg)
static PLINT Xlen
#define plgfont
Definition: plplot.h:726
def plSetUsage
Definition: plplotc.py:8399
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
#define plend1
Definition: plplot.h:699
static const char * _wrap_plgcompression_texinfo
int PLINT
Definition: plplot.h:176
#define plenv0
Definition: plplot.h:701
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer)
#define plgdiori
Definition: plplot.h:720
static const char * _wrap_plgyax_texinfo
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
#define plshades
Definition: plplot.h:813
static const char * _wrap_plgstrm_texinfo
PLINT PLBOOL
Definition: plplot.h:199
static swig_type_info _swigt__p_char
static const char * _wrap_plscmap0a_texinfo
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static const char * _wrap_plstyl_texinfo
static const char * _wrap_pleop_texinfo
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plssym
Definition: plplot.h:826
static const char * _wrap_plgcol0_texinfo
octave_value_list(* octave_func)(const octave_value_list &, int)
static const char * _wrap_plgchr_texinfo
PLFLT_NC_MATRIX yg
Definition: plplot.h:524
static const char * _wrap_plbox_texinfo
#define pljoin
Definition: plplot.h:745
#define plgzax
Definition: plplot.h:739
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_p_char[]
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgfci_texinfo
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
#define plgfam
Definition: plplot.h:723
octave_function * fcnMapForm
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
static const char * _wrap_plGetCursor_texinfo
static const char * _wrap_pllightsource_texinfo
static octave_value make_value_hack(const octave_base_value &x)
static const char * _wrap_plgver_texinfo
PLINT ny
Definition: plplot.h:513
#define plgdidev
Definition: plplot.h:719
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
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plstar
Definition: plplot.h:827
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsvect_texinfo
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
static const char * _wrap_plsfnam_texinfo
static const char * _wrap_plgfam_texinfo
octave_function * fcnCoordTrans
void c_plcont(PLFLT_MATRIX f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plcont.c:508
virtual bool load_ascii(std::istream &is)
swig_member_const_iterator swig_members_begin()
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plcpstrm
Definition: plplot.h:696
static const char * _wrap_plspage_texinfo
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plimagefr
Definition: plplot.h:743
#define plcalc_world
Definition: plplot.h:689
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plstripc_texinfo
void assign(const std::string &name, const swig_octave_member *m)
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[]
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
void assign(const std::string &name, const octave_value &ov)
#define plsfnam
Definition: plplot.h:807
static const char * _wrap_plreplot_texinfo
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
#define plhist
Definition: plplot.h:740
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(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)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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)
virtual bool is_map() const
static PLINT Ylen
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscmap1_range_texinfo
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
#define plgchr
Definition: plplot.h:711
#define SWIG_exception_fail(code, msg)
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_module_info * next
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsdidev
Definition: plplot.h:796
#define SWIG_SetModule(clientdata, pointer)
#define plspal0
Definition: plplot.h:821
static const char * _wrap_plvasp_texinfo
#define SWIG_ERROR
static const char * _wrap_plvsta_texinfo
SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov)
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
#define plfill3
Definition: plplot.h:707
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
void c_plimagefr(PLFLT_MATRIX idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plimage.c:238
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
dim_vector dims(void) const
static swig_module_info swig_module
SWIGRUNTIME octave_value SWIG_ErrorType(int code)
swig_converter_func converter
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(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)
static const char * _wrap_plsdidev_texinfo
#define plseed
Definition: plplot.h:802
def plOptUsage
Definition: plplotc.py:8403
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:512
#define SWIGTYPE_p_unsigned_int
#define plstring
Definition: plplot.h:830
#define plstransform
Definition: plplot.h:829
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plvect
Definition: plplot.h:847
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
#define SWIG_as_voidptr(a)
static const char * _wrap_plwidth_texinfo
static const char * _wrap_plgradient_texinfo
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_DelNewMask(r)
#define SWIG_ArgError(r)
static const char * _wrap_plend1_texinfo
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
static const char * _wrap_plspal0_texinfo
def plResetOpts
Definition: plplotc.py:8395
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plscmap1_texinfo
#define plscmap1la
Definition: plplot.h:786
#define plgfnam
Definition: plplot.h:725
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
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plcont
Definition: plplot.h:695
#define plsxax
Definition: plplot.h:840
#define plstart
Definition: plplot.h:828
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
static const char * _wrap_plshades_texinfo
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
static const char * _wrap_plgvpd_texinfo
PLINT(* defined_func)(PLFLT, PLFLT)
#define pleop
Definition: plplot.h:702
#define plmesh
Definition: plplot.h:759
#define plhlsrgb
Definition: plplot.h:741
swig_type_info ** types
std::string nameCoordTrans
#define SWIGRUNTIME
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)
#define plsmaj
Definition: plplot.h:815
PLINT nx
Definition: plplot.h:525
std::string swig_type_name() const
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgdiplt_texinfo
static const char * _wrap_plvpor_texinfo
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
static const char * _wrap_plflush_texinfo
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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_plenv0(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
#define plcol1
Definition: plplot.h:692
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
#define pllab
Definition: plplot.h:746
#define pllightsource
Definition: plplot.h:748
#define SWIGINTERNINLINE
#define SWIG_as_voidptrptr(a)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plprec_texinfo
#define SWIG_TMPOBJ
#define plbox
Definition: plplot.h:686
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
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_TYPE_TABLE_NAME
#define pltext
Definition: plplot.h:844
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)
dim_vector dims(void) const
static const char * _wrap_plptex_texinfo
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_swig_type & operator=(const octave_swig_type &rhs)
#define plwidth
Definition: plplot.h:852
static swig_type_info _swigt__p_int
#define plgver
Definition: plplot.h:734
virtual bool is_string() const
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscmap0n_texinfo
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscolbg_texinfo
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
#define plscol0a
Definition: plplot.h:790
#define plptex3
Definition: plplot.h:775
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
#define plsdiplz
Definition: plplot.h:800
unsigned int keysym
Definition: plplot.h:441
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsdev_texinfo
static char buf[200]
Definition: tclAPI.c:873
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 SWIG_OCTAVE_BOUND_FUNC(func, args)
#define plspause
Definition: plplot.h:823
const swig_type_info ** base
static swig_type_info * swig_types[10]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plbtime_texinfo
void c_plshades(PLFLT_MATRIX a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT_VECTOR clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plshade.c:216
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plline3
Definition: plplot.h:751
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plstripd
Definition: plplot.h:834
#define plgfci
Definition: plplot.h:724
#define plgspa
Definition: plplot.h:732
#define plgcolbg
Definition: plplot.h:715
static const char * _wrap_plot3dcl_texinfo
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
#define plstripc
Definition: plplot.h:833
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
DEFUN_DLD(subclass, args, nargout, subclass_usage)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plstripa
Definition: plplot.h:832
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgzax_texinfo
#define SWIG_global_name
static const char * _wrap_plenv_texinfo
struct swig_type_info *(* swig_dycast_func)(void **)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plstring3
Definition: plplot.h:831
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_NEWOBJ
static const char * _wrap_plscmap1l_texinfo
#define plvpas
Definition: plplot.h:848
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual bool load_ascii(std::istream &is)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsfont
Definition: plplot.h:808
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)
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:661
static swig_type_info _swigt__p_PLGraphicsIn
void c_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, PLINT_VECTOR label_opts, PLCHAR_MATRIX labels, PLINT n_axes, PLCHAR_MATRIX axis_opts, PLFLT_VECTOR ticks, PLINT_VECTOR sub_ticks, PLINT_VECTOR n_values, PLFLT_MATRIX values)
Definition: pllegend.c:1525
static const char * _wrap_plsurf3dl_texinfo
#define f2c(f, ff, nx, ny)
#define SWIG_IsTmpObj(r)
static const char * _wrap_plfontld_texinfo
#define plpsty
Definition: plplot.h:773
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plerry_texinfo
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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:1223
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plgvpd
Definition: plplot.h:735
virtual string_vector map_keys() const
static swig_octave_class _wrap_class_PLGraphicsIn
#define plpoin
Definition: plplot.h:769
#define plgriddata
Definition: plplot.h:731
virtual bool is_object() const
#define plgvpw
Definition: plplot.h:736
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT wX
Definition: plplot.h:447
#define SWIGRUNTIMEINLINE
PLINT subwindow
Definition: plplot.h:443
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_cast_info _swigc__p_unsigned_int[]
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static int text
Definition: ps.c:77
#define SWIG_IndexError
static const char * _wrap_plgcolbg_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_CAST_NEW_MEMORY
static const char * _wrap_plrandd_texinfo
int max(int a, int b)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plspal1_texinfo
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmtex_texinfo
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
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plbop_texinfo
#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_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plcolorbar_texinfo
#define plmkstrm
Definition: plplot.h:761
void my_plimagefr(const PLFLT *a, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax)
void my_plsurf3dl(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT indexxmin, PLINT indexxmax, const PLINT *indexymin, const PLINT *indexymax)
float PLFLT
Definition: plplot.h:158
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscol0
Definition: plplot.h:789
def pltr2
Definition: plplotc.py:109
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:854
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plxormod_texinfo
#define SWIG_SyntaxError
static const char * _wrap_plerrx_texinfo
#define plflush
Definition: plplot.h:708
#define plerrx
Definition: plplot.h:703
static octave_base_value * default_numeric_conversion_function(const octave_base_value &a)
#define plgcol0a
Definition: plplot.h:714
#define SWIG_IOError
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
#define plgcolbga
Definition: plplot.h:716
static const char * _wrap_plsdiplt_texinfo
static const char * _wrap_plfill_texinfo
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const
static const char * _wrap_plpoly3_texinfo
static const char * _wrap_plscolor_texinfo
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_plgspa(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
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plbin_texinfo
octave_base_value * empty_clone() const
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const
virtual string_vector map_keys() const
#define SWIG_AddCast(r)
#define plgyax
Definition: plplot.h:738
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsesc
Definition: plplot.h:803
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plenv
Definition: plplot.h:700
static PLINT Alen
#define swigreg_unary_op(name)
swig_member_const_iterator swig_members_end()
static const char * _wrap_plsesc_texinfo
virtual Octave_map map_value() const
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
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
static const char * _wrap_plvect_texinfo
static const char * _wrap_plw3d_texinfo
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static swig_type_info _swigt__p_unsigned_int
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plglevel_texinfo
#define SWIG_op_prefix
const swig_octave_member * members
#define plgcmap1_range
Definition: plplot.h:712
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plcol0
Definition: plplot.h:691
virtual double scalar_value(bool frc_str_conv=false) const
#define SWIG_RuntimeError
SWIGRUNTIME void SWIG_InstallOps(int tid)
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plbox3
Definition: plplot.h:687
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN int SWIG_AsVal_char(octave_value obj, char *val)
static int _arraylen(const octave_value &o_obj)
#define plcolorbar
Definition: plplot.h:693
static swig_cast_info * swig_cast_initial[]
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
static const char * _wrap_plstart_texinfo
unsigned int state
Definition: plplot.h:440
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
#define SWIG_fail
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plglevel
Definition: plplot.h:727
virtual bool load_ascii(std::istream &is)
static const char * _wrap_plsurf3d_texinfo
static const char * _wrap_pllab_texinfo
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:512
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
static const char * _wrap_plgpage_texinfo
#define SWIG_ValueError
#define plpoin3
Definition: plplot.h:770
octave_base_value * clone() const
struct swig_cast_info swig_cast_info
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const struct swig_octave_member swig_globals[]
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
void load_members(const swig_octave_class *c, member_map &out) const
static const char * _wrap_plsdiplz_texinfo
#define plscmap0n
Definition: plplot.h:782
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
std::pair< const swig_octave_member *, octave_value > member_value_pair
#define plscolor
Definition: plplot.h:793
#define plsvpa
Definition: plplot.h:839
octave_value_ref(const octave_value_list &_ovl, int _j)
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plpat
Definition: plplot.h:768
#define pl_setcontlabelformat
Definition: plplot.h:679
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap1_range
Definition: plplot.h:788
#define SWIG_POINTER_DISOWN
static const char * _wrap_plcalc_world_texinfo
struct swig_cast_info * prev
virtual std::string string_value(bool force=false) const
static const char * _wrap_plcol1_texinfo
static const char * _wrap_plot3d_texinfo
#define plgcol0
Definition: plplot.h:713
static const char * _wrap_plslabelfunc_texinfo
void c_plvect(PLFLT_MATRIX u, PLFLT_MATRIX v, PLINT nx, PLINT ny, PLFLT scale, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plvect.c:261
static const char * _wrap_plshade_texinfo
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plreplot
Definition: plplot.h:777
swig_cast_info ** cast_initial
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmeshc_texinfo
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plmkstrm_texinfo
unsigned int button
Definition: plplot.h:442
static swig_type_info * swig_type_initial[]
#define SWIG_DEFUN(cname, wname, doc)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plrgbhls_texinfo
static const char * _wrap_plpath_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plgcolbga_texinfo
#define swig_unary_op(name)
#define plscmap1l
Definition: plplot.h:785
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
SWIGRUNTIME octave_swig_type * swig_value_deref(const octave_base_value &ov)
static const char * _wrap_plgfnam_texinfo
#define plprec
Definition: plplot.h:772
#define SWIG_DivisionByZero
static int my_plTranslateCursor(PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in)
static const char * _wrap_plcpstrm_texinfo
void c_plshade(PLFLT_MATRIX a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plshade.c:352
#define plptex
Definition: plplot.h:774
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
static const char * _wrap_plmap_texinfo
const swig_type_info * construct_type
static const char * _wrap_pllsty_texinfo
#define plline
Definition: plplot.h:749
PLFLT dY
Definition: plplot.h:446
#define SWIG_MemoryError
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define SWIG_OCTAVE_PREREQ(major, minor, patch)
PLFLT_NC_MATRIX xg
Definition: plplot.h:524
static const char * _wrap_pllegend_texinfo
static const char * _wrap_plptex3_texinfo
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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:730
static const char * _wrap_plclear_texinfo
static const char * _wrap_plaxes_texinfo
const octave_value_list & ovl
static const char * _wrap_plsdiori_texinfo
swig_type_info ** type_initial
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plend_texinfo
static const char * _wrap_plhlsrgb_texinfo
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plscol0_texinfo
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define pladv
Definition: plplot.h:681
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plvasp
Definition: plplot.h:846
#define plrandd
Definition: plplot.h:776
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
static const char * _wrap_plmaptex_texinfo
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plscmap0
Definition: plplot.h:780
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plssym_texinfo
static int _dim(const octave_value &o_obj, int dim_idx)
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:616
#define plgstrm
Definition: plplot.h:733
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
struct swig_type_info swig_type_info
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
#define plsfci
Definition: plplot.h:806
static swig_octave_member swig_PLGraphicsIn_members[]
static const char * _wrap_plmapfill_texinfo
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
PLFLT wY
Definition: plplot.h:447
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plfamadv_texinfo
char string[PL_MAXKEY]
Definition: plplot.h:444
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
#define plmtex
Definition: plplot.h:762
static const char * _wrap_plgxax_texinfo
#define plrgbhls
Definition: plplot.h:778
#define plsurf3d
Definition: plplot.h:836
static const char * _wrap_plspause_texinfo
def pltr1
Definition: plplotc.py:105
#define plgra
Definition: plplot.h:729
static const char * _wrap_plmapstring_texinfo
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plctime_texinfo
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plsdimap
Definition: plplot.h:797
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plsvpa_texinfo
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
static swig_cast_info _swigc__p_PLGraphicsIn[]
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
static const char * _wrap_plvpas_texinfo
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
#define plot3d
Definition: plplot.h:764
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
static const char * _wrap_plconfigtime_texinfo
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
#define plslabelfunc
Definition: plplot.h:814
PLINT nx
Definition: plplot.h:513
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
static const char * _wrap_plot3dc_texinfo
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
void __swig_atexit__(void)
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
static const char * _wrap_plscmap0_texinfo
#define SWIG_NewPointerObj(ptr, type, flags)
std::vector< type_ptr_pair > types
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
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)