PLplot  5.15.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.2
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 // This header includes all C++ headers required for generated Octave wrapper code.
172 // Using a single header file allows pre-compilation of Octave headers, as follows:
173 // * Check out this header file:
174 // swig -octave -co octheaders.hpp
175 // * Pre-compile header file into octheaders.hpp.gch:
176 // g++ -c ... octheaders.hpp
177 // * Use pre-compiled header file:
178 // g++ -c -include octheaders.hpp ...
179 //
180 
181 #if !defined(_SWIG_OCTAVE_OCTHEADERS_HPP)
182 #define _SWIG_OCTAVE_OCTHEADERS_HPP
183 
184 // Required C++ headers
185 #include <cstdlib>
186 #include <climits>
187 #include <iostream>
188 #include <exception>
189 #include <functional>
190 #include <complex>
191 #include <string>
192 #include <vector>
193 #include <map>
194 
195 // Minimal headers to define Octave version
196 #include <octave/oct.h>
197 #include <octave/version.h>
198 
199 // Macro for enabling features which require Octave version >= major.minor.patch
200 // - Use (OCTAVE_PATCH_VERSION + 0) to handle both '<digit>' (released) and '<digit>+' (in development) patch numbers
201 #define SWIG_OCTAVE_PREREQ(major, minor, patch) \
202  ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
203 
204 // Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
205 #if !defined(OCTAVE_MAJOR_VERSION)
206 
207 # if !defined(OCTAVE_API_VERSION_NUMBER)
208 
209 // Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
210 // introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
211 # include <octave/ov.h>
212 # if defined(octave_ov_h)
213 # define OCTAVE_MAJOR_VERSION 3
214 # define OCTAVE_MINOR_VERSION 8
215 # define OCTAVE_PATCH_VERSION 0
216 # else
217 
218 // Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
219 # define ComplexLU __ignore
220 # include <octave/CmplxLU.h>
221 # undef ComplexLU
222 # if defined(octave_Complex_LU_h)
223 
224 // We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
225 # define OCTAVE_MAJOR_VERSION 3
226 # define OCTAVE_MINOR_VERSION 1
227 # define OCTAVE_PATCH_VERSION 99
228 
229 # else
230 
231 // OCTAVE_API_VERSION_NUMBER == 37
232 # define OCTAVE_MAJOR_VERSION 3
233 # define OCTAVE_MINOR_VERSION 2
234 # define OCTAVE_PATCH_VERSION 0
235 
236 # endif // defined(octave_Complex_LU_h)
237 
238 # endif // defined(octave_ov_h)
239 
240 // Correlation between Octave API and version numbers extracted from Octave's
241 // ChangeLogs; version is the *earliest* released Octave with that API number
242 # elif OCTAVE_API_VERSION_NUMBER >= 48
243 # define OCTAVE_MAJOR_VERSION 3
244 # define OCTAVE_MINOR_VERSION 6
245 # define OCTAVE_PATCH_VERSION 0
246 
247 # elif OCTAVE_API_VERSION_NUMBER >= 45
248 # define OCTAVE_MAJOR_VERSION 3
249 # define OCTAVE_MINOR_VERSION 4
250 # define OCTAVE_PATCH_VERSION 1
251 
252 # elif OCTAVE_API_VERSION_NUMBER >= 42
253 # define OCTAVE_MAJOR_VERSION 3
254 # define OCTAVE_MINOR_VERSION 3
255 # define OCTAVE_PATCH_VERSION 54
256 
257 # elif OCTAVE_API_VERSION_NUMBER >= 41
258 # define OCTAVE_MAJOR_VERSION 3
259 # define OCTAVE_MINOR_VERSION 3
260 # define OCTAVE_PATCH_VERSION 53
261 
262 # elif OCTAVE_API_VERSION_NUMBER >= 40
263 # define OCTAVE_MAJOR_VERSION 3
264 # define OCTAVE_MINOR_VERSION 3
265 # define OCTAVE_PATCH_VERSION 52
266 
267 # elif OCTAVE_API_VERSION_NUMBER >= 39
268 # define OCTAVE_MAJOR_VERSION 3
269 # define OCTAVE_MINOR_VERSION 3
270 # define OCTAVE_PATCH_VERSION 51
271 
272 # else // OCTAVE_API_VERSION_NUMBER == 38
273 # define OCTAVE_MAJOR_VERSION 3
274 # define OCTAVE_MINOR_VERSION 3
275 # define OCTAVE_PATCH_VERSION 50
276 
277 # endif // !defined(OCTAVE_API_VERSION_NUMBER)
278 
279 #endif // !defined(OCTAVE_MAJOR_VERSION)
280 
281 // Required Octave headers
282 #include <octave/Cell.h>
283 #include <octave/dynamic-ld.h>
284 #include <octave/oct-env.h>
285 #include <octave/oct-map.h>
286 #include <octave/ov-scalar.h>
287 #include <octave/ov-fcn-handle.h>
288 #include <octave/parse.h>
289 #if SWIG_OCTAVE_PREREQ(4,2,0)
290 #include <octave/interpreter.h>
291 #else
292 #include <octave/toplev.h>
293 #endif
294 #include <octave/unwind-prot.h>
295 #if SWIG_OCTAVE_PREREQ(4,2,0)
296 #include <octave/call-stack.h>
297 #endif
298 
299 #endif // !defined(_SWIG_OCTAVE_OCTHEADERS_HPP)
300 
301 /* -----------------------------------------------------------------------------
302  * swigrun.swg
303  *
304  * This file contains generic C API SWIG runtime support for pointer
305  * type checking.
306  * ----------------------------------------------------------------------------- */
307 
308 /* This should only be incremented when either the layout of swig_type_info changes,
309  or for whatever reason, the runtime changes incompatibly */
310 #define SWIG_RUNTIME_VERSION "4"
311 
312 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
313 #ifdef SWIG_TYPE_TABLE
314 # define SWIG_QUOTE_STRING(x) #x
315 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
316 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
317 #else
318 # define SWIG_TYPE_TABLE_NAME
319 #endif
320 
321 /*
322  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
323  creating a static or dynamic library from the SWIG runtime code.
324  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
325 
326  But only do this if strictly necessary, ie, if you have problems
327  with your compiler or suchlike.
328 */
329 
330 #ifndef SWIGRUNTIME
331 # define SWIGRUNTIME SWIGINTERN
332 #endif
333 
334 #ifndef SWIGRUNTIMEINLINE
335 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
336 #endif
337 
338 /* Generic buffer size */
339 #ifndef SWIG_BUFFER_SIZE
340 # define SWIG_BUFFER_SIZE 1024
341 #endif
342 
343 /* Flags for pointer conversions */
344 #define SWIG_POINTER_DISOWN 0x1
345 #define SWIG_CAST_NEW_MEMORY 0x2
346 #define SWIG_POINTER_NO_NULL 0x4
347 
348 /* Flags for new pointer objects */
349 #define SWIG_POINTER_OWN 0x1
350 
351 
352 /*
353  Flags/methods for returning states.
354 
355  The SWIG conversion methods, as ConvertPtr, return an integer
356  that tells if the conversion was successful or not. And if not,
357  an error code can be returned (see swigerrors.swg for the codes).
358 
359  Use the following macros/flags to set or process the returning
360  states.
361 
362  In old versions of SWIG, code such as the following was usually written:
363 
364  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
365  // success code
366  } else {
367  //fail code
368  }
369 
370  Now you can be more explicit:
371 
372  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
373  if (SWIG_IsOK(res)) {
374  // success code
375  } else {
376  // fail code
377  }
378 
379  which is the same really, but now you can also do
380 
381  Type *ptr;
382  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
383  if (SWIG_IsOK(res)) {
384  // success code
385  if (SWIG_IsNewObj(res) {
386  ...
387  delete *ptr;
388  } else {
389  ...
390  }
391  } else {
392  // fail code
393  }
394 
395  I.e., now SWIG_ConvertPtr can return new objects and you can
396  identify the case and take care of the deallocation. Of course that
397  also requires SWIG_ConvertPtr to return new result values, such as
398 
399  int SWIG_ConvertPtr(obj, ptr,...) {
400  if (<obj is ok>) {
401  if (<need new object>) {
402  *ptr = <ptr to new allocated object>;
403  return SWIG_NEWOBJ;
404  } else {
405  *ptr = <ptr to old object>;
406  return SWIG_OLDOBJ;
407  }
408  } else {
409  return SWIG_BADOBJ;
410  }
411  }
412 
413  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
414  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
415  SWIG errors code.
416 
417  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
418  allows to return the 'cast rank', for example, if you have this
419 
420  int food(double)
421  int fooi(int);
422 
423  and you call
424 
425  food(1) // cast rank '1' (1 -> 1.0)
426  fooi(1) // cast rank '0'
427 
428  just use the SWIG_AddCast()/SWIG_CheckState()
429 */
430 
431 #define SWIG_OK (0)
432 #define SWIG_ERROR (-1)
433 #define SWIG_IsOK(r) (r >= 0)
434 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
435 
436 /* The CastRankLimit says how many bits are used for the cast rank */
437 #define SWIG_CASTRANKLIMIT (1 << 8)
438 /* The NewMask denotes the object was created (using new/malloc) */
439 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
440 /* The TmpMask is for in/out typemaps that use temporal objects */
441 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
442 /* Simple returning values */
443 #define SWIG_BADOBJ (SWIG_ERROR)
444 #define SWIG_OLDOBJ (SWIG_OK)
445 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
446 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
447 /* Check, add and del mask methods */
448 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
449 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
450 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
451 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
452 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
453 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
454 
455 /* Cast-Rank Mode */
456 #if defined(SWIG_CASTRANK_MODE)
457 # ifndef SWIG_TypeRank
458 # define SWIG_TypeRank unsigned long
459 # endif
460 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
461 # define SWIG_MAXCASTRANK (2)
462 # endif
463 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
464 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
465 SWIGINTERNINLINE int SWIG_AddCast(int r) {
466  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
467 }
469  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
470 }
471 #else /* no cast-rank mode */
472 # define SWIG_AddCast(r) (r)
473 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
474 #endif
475 
476 
477 #include <string.h>
478 
479 #ifdef __cplusplus
480 extern "C" {
481 #endif
482 
483 typedef void *(*swig_converter_func)(void *, int *);
484 typedef struct swig_type_info *(*swig_dycast_func)(void **);
485 
486 /* Structure to store information on one type */
487 typedef struct swig_type_info {
488  const char *name; /* mangled name of this type */
489  const char *str; /* human readable name of this type */
490  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
491  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
492  void *clientdata; /* language specific type data */
493  int owndata; /* flag if the structure owns the clientdata */
495 
496 /* Structure to store a type and conversion function used for casting */
497 typedef struct swig_cast_info {
498  swig_type_info *type; /* pointer to type that is equivalent to this type */
499  swig_converter_func converter; /* function to cast the void pointers */
500  struct swig_cast_info *next; /* pointer to next cast in linked list */
501  struct swig_cast_info *prev; /* pointer to the previous cast */
503 
504 /* Structure used to store module information
505  * Each module generates one structure like this, and the runtime collects
506  * all of these structures and stores them in a circularly linked list.*/
507 typedef struct swig_module_info {
508  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
509  size_t size; /* Number of types in this module */
510  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
511  swig_type_info **type_initial; /* Array of initially generated type structures */
512  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
513  void *clientdata; /* Language specific module data */
515 
516 /*
517  Compare two type names skipping the space characters, therefore
518  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
519 
520  Return 0 when the two name types are equivalent, as in
521  strncmp, but skipping ' '.
522 */
523 SWIGRUNTIME int
524 SWIG_TypeNameComp(const char *f1, const char *l1,
525  const char *f2, const char *l2) {
526  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
527  while ((*f1 == ' ') && (f1 != l1)) ++f1;
528  while ((*f2 == ' ') && (f2 != l2)) ++f2;
529  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
530  }
531  return (int)((l1 - f1) - (l2 - f2));
532 }
533 
534 /*
535  Check type equivalence in a name list like <name1>|<name2>|...
536  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
537 */
538 SWIGRUNTIME int
539 SWIG_TypeCmp(const char *nb, const char *tb) {
540  int equiv = 1;
541  const char* te = tb + strlen(tb);
542  const char* ne = nb;
543  while (equiv != 0 && *ne) {
544  for (nb = ne; *ne; ++ne) {
545  if (*ne == '|') break;
546  }
547  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
548  if (*ne) ++ne;
549  }
550  return equiv;
551 }
552 
553 /*
554  Check type equivalence in a name list like <name1>|<name2>|...
555  Return 0 if not equal, 1 if equal
556 */
557 SWIGRUNTIME int
558 SWIG_TypeEquiv(const char *nb, const char *tb) {
559  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
560 }
561 
562 /*
563  Check the typename
564 */
566 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
567  if (ty) {
568  swig_cast_info *iter = ty->cast;
569  while (iter) {
570  if (strcmp(iter->type->name, c) == 0) {
571  if (iter == ty->cast)
572  return iter;
573  /* Move iter to the top of the linked list */
574  iter->prev->next = iter->next;
575  if (iter->next)
576  iter->next->prev = iter->prev;
577  iter->next = ty->cast;
578  iter->prev = 0;
579  if (ty->cast) ty->cast->prev = iter;
580  ty->cast = iter;
581  return iter;
582  }
583  iter = iter->next;
584  }
585  }
586  return 0;
587 }
588 
589 /*
590  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
591 */
594  if (ty) {
595  swig_cast_info *iter = ty->cast;
596  while (iter) {
597  if (iter->type == from) {
598  if (iter == ty->cast)
599  return iter;
600  /* Move iter to the top of the linked list */
601  iter->prev->next = iter->next;
602  if (iter->next)
603  iter->next->prev = iter->prev;
604  iter->next = ty->cast;
605  iter->prev = 0;
606  if (ty->cast) ty->cast->prev = iter;
607  ty->cast = iter;
608  return iter;
609  }
610  iter = iter->next;
611  }
612  }
613  return 0;
614 }
615 
616 /*
617  Cast a pointer up an inheritance hierarchy
618 */
619 SWIGRUNTIMEINLINE void *
620 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
621  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
622 }
623 
624 /*
625  Dynamic pointer casting. Down an inheritance hierarchy
626 */
629  swig_type_info *lastty = ty;
630  if (!ty || !ty->dcast) return ty;
631  while (ty && (ty->dcast)) {
632  ty = (*ty->dcast)(ptr);
633  if (ty) lastty = ty;
634  }
635  return lastty;
636 }
637 
638 /*
639  Return the name associated with this type
640 */
641 SWIGRUNTIMEINLINE const char *
643  return ty->name;
644 }
645 
646 /*
647  Return the pretty name associated with this type,
648  that is an unmangled type name in a form presentable to the user.
649 */
650 SWIGRUNTIME const char *
652  /* The "str" field contains the equivalent pretty names of the
653  type, separated by vertical-bar characters. We choose
654  to print the last name, as it is often (?) the most
655  specific. */
656  if (!type) return NULL;
657  if (type->str != NULL) {
658  const char *last_name = type->str;
659  const char *s;
660  for (s = type->str; *s; s++)
661  if (*s == '|') last_name = s+1;
662  return last_name;
663  }
664  else
665  return type->name;
666 }
667 
668 /*
669  Set the clientdata field for a type
670 */
671 SWIGRUNTIME void
673  swig_cast_info *cast = ti->cast;
674  /* if (ti->clientdata == clientdata) return; */
675  ti->clientdata = clientdata;
676 
677  while (cast) {
678  if (!cast->converter) {
679  swig_type_info *tc = cast->type;
680  if (!tc->clientdata) {
682  }
683  }
684  cast = cast->next;
685  }
686 }
687 SWIGRUNTIME void
690  ti->owndata = 1;
691 }
692 
693 /*
694  Search for a swig_type_info structure only by mangled name
695  Search is a O(log #types)
696 
697  We start searching at module start, and finish searching when start == end.
698  Note: if start == end at the beginning of the function, we go all the way around
699  the circular list.
700 */
703  swig_module_info *end,
704  const char *name) {
705  swig_module_info *iter = start;
706  do {
707  if (iter->size) {
708  size_t l = 0;
709  size_t r = iter->size - 1;
710  do {
711  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
712  size_t i = (l + r) >> 1;
713  const char *iname = iter->types[i]->name;
714  if (iname) {
715  int compare = strcmp(name, iname);
716  if (compare == 0) {
717  return iter->types[i];
718  } else if (compare < 0) {
719  if (i) {
720  r = i - 1;
721  } else {
722  break;
723  }
724  } else if (compare > 0) {
725  l = i + 1;
726  }
727  } else {
728  break; /* should never happen */
729  }
730  } while (l <= r);
731  }
732  iter = iter->next;
733  } while (iter != end);
734  return 0;
735 }
736 
737 /*
738  Search for a swig_type_info structure for either a mangled name or a human readable name.
739  It first searches the mangled names of the types, which is a O(log #types)
740  If a type is not found it then searches the human readable names, which is O(#types).
741 
742  We start searching at module start, and finish searching when start == end.
743  Note: if start == end at the beginning of the function, we go all the way around
744  the circular list.
745 */
748  swig_module_info *end,
749  const char *name) {
750  /* STEP 1: Search the name field using binary search */
751  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
752  if (ret) {
753  return ret;
754  } else {
755  /* STEP 2: If the type hasn't been found, do a complete search
756  of the str field (the human readable name) */
757  swig_module_info *iter = start;
758  do {
759  size_t i = 0;
760  for (; i < iter->size; ++i) {
761  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
762  return iter->types[i];
763  }
764  iter = iter->next;
765  } while (iter != end);
766  }
767 
768  /* neither found a match */
769  return 0;
770 }
771 
772 /*
773  Pack binary data into a string
774 */
775 SWIGRUNTIME char *
776 SWIG_PackData(char *c, void *ptr, size_t sz) {
777  static const char hex[17] = "0123456789abcdef";
778  const unsigned char *u = (unsigned char *) ptr;
779  const unsigned char *eu = u + sz;
780  for (; u != eu; ++u) {
781  unsigned char uu = *u;
782  *(c++) = hex[(uu & 0xf0) >> 4];
783  *(c++) = hex[uu & 0xf];
784  }
785  return c;
786 }
787 
788 /*
789  Unpack binary data from a string
790 */
791 SWIGRUNTIME const char *
792 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
793  unsigned char *u = (unsigned char *) ptr;
794  const unsigned char *eu = u + sz;
795  for (; u != eu; ++u) {
796  char d = *(c++);
797  unsigned char uu;
798  if ((d >= '0') && (d <= '9'))
799  uu = (unsigned char)((d - '0') << 4);
800  else if ((d >= 'a') && (d <= 'f'))
801  uu = (unsigned char)((d - ('a'-10)) << 4);
802  else
803  return (char *) 0;
804  d = *(c++);
805  if ((d >= '0') && (d <= '9'))
806  uu |= (unsigned char)(d - '0');
807  else if ((d >= 'a') && (d <= 'f'))
808  uu |= (unsigned char)(d - ('a'-10));
809  else
810  return (char *) 0;
811  *u = uu;
812  }
813  return c;
814 }
815 
816 /*
817  Pack 'void *' into a string buffer.
818 */
819 SWIGRUNTIME char *
820 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
821  char *r = buff;
822  if ((2*sizeof(void *) + 2) > bsz) return 0;
823  *(r++) = '_';
824  r = SWIG_PackData(r,&ptr,sizeof(void *));
825  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
826  strcpy(r,name);
827  return buff;
828 }
829 
830 SWIGRUNTIME const char *
831 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
832  if (*c != '_') {
833  if (strcmp(c,"NULL") == 0) {
834  *ptr = (void *) 0;
835  return name;
836  } else {
837  return 0;
838  }
839  }
840  return SWIG_UnpackData(++c,ptr,sizeof(void *));
841 }
842 
843 SWIGRUNTIME char *
844 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
845  char *r = buff;
846  size_t lname = (name ? strlen(name) : 0);
847  if ((2*sz + 2 + lname) > bsz) return 0;
848  *(r++) = '_';
849  r = SWIG_PackData(r,ptr,sz);
850  if (lname) {
851  strncpy(r,name,lname+1);
852  } else {
853  *r = 0;
854  }
855  return buff;
856 }
857 
858 SWIGRUNTIME const char *
859 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
860  if (*c != '_') {
861  if (strcmp(c,"NULL") == 0) {
862  memset(ptr,0,sz);
863  return name;
864  } else {
865  return 0;
866  }
867  }
868  return SWIG_UnpackData(++c,ptr,sz);
869 }
870 
871 #ifdef __cplusplus
872 }
873 #endif
874 
875 /* Errors in SWIG */
876 #define SWIG_UnknownError -1
877 #define SWIG_IOError -2
878 #define SWIG_RuntimeError -3
879 #define SWIG_IndexError -4
880 #define SWIG_TypeError -5
881 #define SWIG_DivisionByZero -6
882 #define SWIG_OverflowError -7
883 #define SWIG_SyntaxError -8
884 #define SWIG_ValueError -9
885 #define SWIG_SystemError -10
886 #define SWIG_AttributeError -11
887 #define SWIG_MemoryError -12
888 #define SWIG_NullReferenceError -13
889 
890 
891 
892 #if !SWIG_OCTAVE_PREREQ(3,2,0)
893 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
894 #else
895 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
896 #endif
897 
898 SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
899  if (num_args > max_args && !varargs)
900  error("function %s takes at most %i arguments", func_name, max_args);
901  else if (num_args < min_args)
902  error("function %s requires at least %i arguments", func_name, min_args);
903  else
904  return true;
905  return false;
906 }
907 
908 SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
909  ovl->append(ov);
910  return ovl;
911 }
912 
913 SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
914  switch (code) {
915  case SWIG_MemoryError:
916  return "SWIG_MemoryError";
917  case SWIG_IOError:
918  return "SWIG_IOError";
919  case SWIG_RuntimeError:
920  return "SWIG_RuntimeError";
921  case SWIG_IndexError:
922  return "SWIG_IndexError";
923  case SWIG_TypeError:
924  return "SWIG_TypeError";
925  case SWIG_DivisionByZero:
926  return "SWIG_DivisionByZero";
927  case SWIG_OverflowError:
928  return "SWIG_OverflowError";
929  case SWIG_SyntaxError:
930  return "SWIG_SyntaxError";
931  case SWIG_ValueError:
932  return "SWIG_ValueError";
933  case SWIG_SystemError:
934  return "SWIG_SystemError";
935  case SWIG_AttributeError:
936  return "SWIG_AttributeError";
937  }
938  return "SWIG unknown error";
939 }
940 
941 SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
942  octave_value type(SWIG_ErrorType(code));
943  std::string r = msg;
944  r += " (" + type.string_value() + ")";
945  error("%s", r.c_str());
946  return octave_value(r);
947 }
948 
949 #define SWIG_fail goto fail
950 
951 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
952 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
953 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
954 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
955 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
956 #define swig_owntype int
957 
958 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
959 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
960 
961 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
962 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
963 
964 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
965 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
966 
967 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
968 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
969 #define SWIG_MODULE_CLIENTDATA_TYPE void*
970 
971 #define Octave_Error_Occurred() 0
972 #define SWIG_Octave_AddErrorMsg(msg) {;}
973 
976 
977 // For backward compatibility only
978 #define SWIG_POINTER_EXCEPTION 0
979 #define SWIG_arg_fail(arg) 0
980 
981 // Runtime API implementation
982 
983 typedef octave_value_list(*octave_func) (const octave_value_list &, int);
984 class octave_swig_type;
985 
986 namespace Swig {
987 
988 #ifdef SWIG_DIRECTORS
989 
990  class Director;
991 
992  typedef std::map < void *, Director * > rtdir_map;
993  SWIGINTERN rtdir_map* get_rtdir_map();
994  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
995  SWIGINTERNINLINE void erase_rtdir(void *vptr);
996  SWIGINTERNINLINE Director *get_rtdir(void *vptr);
997 
998  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
999  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
1000  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
1001 
1002 #endif
1003 
1004  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
1005  SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov);
1006  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
1007 }
1008 
1009 #ifdef SWIG_DIRECTORS
1010 SWIGRUNTIME void swig_acquire_ownership(void *vptr);
1011 SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
1012 SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
1013 #endif
1014 
1016  const char *name;
1020  int flags; // 1 static, 2 global
1021  const char *doc;
1022  bool is_static() const {
1023  return flags &1;
1024  } bool is_global() const {
1025  return flags &2;
1026  }
1027  };
1028 
1030  const char *name;
1034  const char *constructor_doc;
1037  const char **base_names;
1039  };
1040 
1041 #if SWIG_OCTAVE_PREREQ(4,4,0)
1042  // in Octave 4.4 behaviour of octave_builtin() appears to have changed and 'self' argument is no longer passed
1043  // to function (maybe because this is now a 'method'??) so need to create our own octave_function subclass
1044 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1045  class octave_swig_bound_func : public octave_function {
1046  public:
1047 
1048  octave_swig_bound_func(void) : octave_function(), method(0), first_args()
1049  { }
1050 
1051  octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1052  : octave_function("", ""), method(_method), first_args(_first_args)
1053  { }
1054 
1055  octave_swig_bound_func(const octave_swig_bound_func& f) = delete;
1056 
1057  octave_swig_bound_func& operator= (const octave_swig_bound_func& f) = delete;
1058 
1059  ~octave_swig_bound_func(void) = default;
1060 
1061  bool is_function(void) const { return true; }
1062 
1063  octave_function* function_value(bool = false) { return this; }
1064 
1065  octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1066  octave_value_list all_args;
1067  all_args.append(first_args);
1068  all_args.append(args);
1069  return method->call(tw, nargout, all_args);
1070  }
1071 
1072  octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1073  octave_value_list ovl = subsref(ops, idx, 1);
1074  return ovl.length() ? ovl(0) : octave_value();
1075  }
1076 
1077  octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1078  assert(ops.size() > 0);
1079  assert(ops.size() == idx.size());
1080  if (ops != "(")
1081  error("invalid function call");
1082  octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1083  return call(tw, nargout, *idx.begin());
1084  }
1085 
1086  protected:
1087 
1088  octave_function* method;
1089  octave_value_list first_args;
1090 
1091  std::set<std::string> dispatch_classes;
1092 
1093  };
1094 #else
1095 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1096 #endif
1097 
1098  // octave_swig_type plays the role of both the shadow class and the class
1099  // representation within Octave, since there is no support for classes.
1100  //
1101  // These should really be decoupled, with the class support added to Octave
1102  // and the shadow class given by an m-file script. That would dramatically
1103  // reduce the runtime complexity, and be more in line w/ other modules.
1104 
1105  class octave_swig_type:public octave_base_value {
1106  struct cpp_ptr {
1107  void *ptr;
1109  cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1110  }};
1111  typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1112 
1114 
1115  const swig_type_info *construct_type; // type of special type object
1116  std::vector < type_ptr_pair > types; // our c++ base classes
1117  int own; // whether we call c++ destructors when we die
1118 
1119  typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1120  typedef std::map < std::string, member_value_pair > member_map;
1123 
1124  const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
1125  if (!type->clientdata)
1126  return 0;
1128  const swig_octave_member *m;
1129  for (m = c->members; m->name; ++m)
1130  if (m->name == name)
1131  return m;
1132  for (int j = 0; c->base_names[j]; ++j) {
1133  if (!c->base[j]) {
1134  if (!module)
1135  module = SWIG_GetModule(0);
1136  assert(module);
1138  }
1139  if (!c->base[j])
1140  return 0;
1141  if ((m = find_member(c->base[j], name)))
1142  return m;
1143  }
1144  return 0;
1145  }
1146 
1147  member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1148  member_map::iterator it = members.find(name);
1149  if (it != members.end())
1150  return &it->second;
1151  const swig_octave_member *m;
1152  for (unsigned int j = 0; j < types.size(); ++j)
1153  if ((m = find_member(types[j].first, name)))
1154  return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1155  if (!insert_if_not_found)
1156  return 0;
1157  return &members[name];
1158  }
1159 
1160  const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
1161  if (!base) {
1162  for (unsigned int j = 0; j < types.size(); ++j) {
1163  assert(types[j].first->clientdata);
1164  swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1165  if (cj->name == name)
1166  return types[j].first;
1167  }
1168  return 0;
1169  }
1170  assert(base->clientdata);
1172  for (int j = 0; c->base_names[j]; ++j) {
1173  if (!c->base[j]) {
1174  if (!module)
1175  module = SWIG_GetModule(0);
1176  assert(module);
1178  }
1179  if (!c->base[j])
1180  return 0;
1181  assert(c->base[j]->clientdata);
1183  if (cj->name == name)
1184  return c->base[j];
1185  }
1186  return 0;
1187  }
1188 
1189  void load_members(const swig_octave_class* c,member_map& out) const {
1190  for (const swig_octave_member *m = c->members; m->name; ++m) {
1191  if (out.find(m->name) == out.end())
1192  out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1193  }
1194  for (int j = 0; c->base_names[j]; ++j) {
1195  if (!c->base[j]) {
1196  if (!module)
1197  module = SWIG_GetModule(0);
1198  assert(module);
1200  }
1201  if (!c->base[j])
1202  continue;
1203  assert(c->base[j]->clientdata);
1204  const swig_octave_class *cj =
1205  (const swig_octave_class *) c->base[j]->clientdata;
1206  load_members(cj,out);
1207  }
1208  }
1209 
1210  void load_members(member_map& out) const {
1211  out=members;
1212  for (unsigned int j = 0; j < types.size(); ++j)
1213  if (types[j].first->clientdata)
1214  load_members((const swig_octave_class *) types[j].first->clientdata, out);
1215  }
1216 
1217  octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1218  if (m->second.is_defined())
1219  return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1220  else if (m->first && m->first->method)
1221  return m->first->method(args, nargout);
1222  error("member not defined or not invocable");
1223  return octave_value_list();
1224  }
1225 
1226  bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
1227  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1228  member_value_pair *m = nc_this->find_member(symbol, false);
1229  if (!m || m->first->is_static() || m->first->is_global())
1230  return false;
1231  octave_value_list args;
1232  args.append(nc_this->as_value());
1233  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1234  if (argout.length() < 1)
1235  return false;
1236  ret = argout(0);
1237  return true;
1238  }
1239 
1240  bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
1241  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1242  member_value_pair *m = nc_this->find_member(symbol, false);
1243  if (!m || m->first->is_static() || m->first->is_global())
1244  return false;
1245  octave_value_list args;
1246  args.append(nc_this->as_value());
1247  args.append(make_value_hack(rhs));
1248  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1249  if (argout.length() < 1)
1250  return false;
1251  ret = argout(0);
1252  return true;
1253  }
1254 
1255  bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
1256  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1257  member_value_pair *m = nc_this->find_member(symbol, false);
1258  if (!m || m->first->is_static() || m->first->is_global())
1259  return false;
1260  octave_value_list args;
1261  args.append(nc_this->as_value());
1262  args.append(rhs);
1263  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1264  if (argout.length() >= 1)
1265  ret = argout(0);
1266  return true;
1267  }
1268 
1269  octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1270  if (m->second.is_defined()) {
1271  if (m->second.is_function() || m->second.is_function_handle()) {
1272  return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args);
1273  } else {
1274  return m->second;
1275  }
1276  } else if (m->first) {
1277  if (m->first->get_method)
1278  return m->first->get_method(args, 1);
1279  else if (m->first->method)
1280  return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args);
1281  }
1282  error("undefined member");
1283  return octave_value_list();
1284  }
1285 
1286  static octave_value make_value_hack(const octave_base_value &x) {
1287  ((octave_swig_type &) x).count++;
1288  return octave_value((octave_base_value *) &x);
1289  }
1290 
1293  public:
1294 
1295  octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1296  bool _always_static = false)
1297  : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1298  always_static(_always_static) {
1299  if (_type || _ptr)
1300  types.push_back(std::make_pair(_type, _ptr));
1301 #ifdef SWIG_DIRECTORS
1302  if (_ptr) {
1303  Swig::Director *d = Swig::get_rtdir(_ptr);
1304  if (d)
1305  Swig::swig_director_set_self(d, this);
1306  }
1307 #endif
1308  }
1309 
1311  if (own) {
1312  ++count;
1313  for (unsigned int j = 0; j < types.size(); ++j) {
1314  if (!types[j].first || !types[j].first->clientdata)
1315  continue;
1316  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1317  if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1318  c->destructor(as_value(), 0);
1319  }
1320  }
1321  }
1322 #ifdef SWIG_DIRECTORS
1323  for (unsigned int j = 0; j < types.size(); ++j)
1324  Swig::erase_rtdir(types[j].second.ptr);
1325 #endif
1326  }
1327 
1328  dim_vector dims(void) const {
1329  octave_value out;
1330  if (!dispatch_unary_op("__dims__", out))
1331  return dim_vector(1,1);
1332 
1333  // Return value should be cell or matrix of integers
1334 #if SWIG_OCTAVE_PREREQ(4,4,0)
1335  if (out.iscell()) {
1336 #else
1337  if (out.is_cell()) {
1338 #endif
1339  const Cell & c=out.cell_value();
1340  int ndim = c.rows();
1341  if (ndim==1 && c.columns()!=1) ndim = c.columns();
1342 
1343  dim_vector d;
1344  d.resize(ndim < 2 ? 2 : ndim);
1345  d(0) = d(1) = 1;
1346 
1347  // Fill in dim_vector
1348  for (int k=0;k<ndim;k++) {
1349  const octave_value& obj = c(k);
1350  d.elem(k) = obj.int_value();
1351 
1352  // __dims__ should return a cell filled with integers
1353  if (error_state) return dim_vector(1,1);
1354  }
1355  return d;
1356 #if SWIG_OCTAVE_PREREQ(4,4,0)
1357  } else if (out.is_matrix_type() || out.isnumeric() ) {
1358 #else
1359  } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1360 #endif
1361  if (out.rows()==1 || out.columns()==1) {
1362  Array<int> a = out.int_vector_value();
1363  if (error_state) return dim_vector(1,1);
1364  dim_vector d;
1365  d.resize(a.numel() < 2 ? 2 : a.numel());
1366  d(0) = d(1) = 1;
1367  for (int k=0;k<a.numel();k++) {
1368  d.elem(k) = a(k);
1369  }
1370  return d;
1371  } else {
1372  return dim_vector(1,1);
1373  }
1374  } else {
1375  return dim_vector(1,1);
1376  }
1377  }
1378 
1379  octave_value as_value() {
1380  ++count;
1381  return Swig::swig_value_ref(this);
1382  }
1383 
1384  void incref() {
1385  ++count;
1386  }
1387 
1388  void decref() {
1389  if (!--count)
1390  delete this;
1391  }
1392 
1393  size_t swig_this() const {
1394  if (!types.size())
1395  return (size_t) this;
1396  return (size_t) types[0].second.ptr;
1397  }
1398  const char* help_text() const {
1399  if (!types.size())
1400  return 0;
1401  if (!types[0].first->clientdata)
1402  return 0;
1403  swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1404  return c->constructor_doc;
1405  }
1406 
1407  std::string swig_type_name() const {
1408  // * need some way to manually name subclasses.
1409  // * eg optional first arg to subclass(), or named_subclass()
1410  std::string ret;
1411  for (unsigned int j = 0; j < types.size(); ++j) {
1412  if (j)
1413  ret += "_";
1414  if (types[j].first->clientdata) {
1415  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1416  ret += c->name;
1417  } else
1418  ret += types[j].first->name;
1419  }
1420  return ret;
1421  }
1422 
1424  rhs.own = 0;
1425  for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1426  assert(!rhs.types[j].second.destroyed);
1427 #ifdef SWIG_DIRECTORS
1428  Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1429  if (d)
1430  Swig::swig_director_set_self(d, this);
1431 #endif
1432  }
1433  types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1434  members.insert(rhs.members.begin(), rhs.members.end());
1435 #if SWIG_OCTAVE_PREREQ(4,4,0)
1436  assign(rhs.swig_type_name(), rhs.as_value());
1437 #else
1438  rhs.types.clear();
1439  rhs.members.clear();
1440 #endif
1441  }
1442 
1443  typedef member_map::const_iterator swig_member_const_iterator;
1446 
1447  int cast(void **vptr, swig_type_info *type, int *_own, int flags) {
1448  int res = SWIG_ERROR;
1449  if (_own)
1450  *_own = own;
1451  if (flags &SWIG_POINTER_DISOWN)
1452  own = 0;
1453  if (!type && types.size()) {
1454  if(vptr)
1455  *vptr = types[0].second.ptr;
1456  return SWIG_OK;
1457  }
1458  for (unsigned int j = 0; j < types.size(); ++j)
1459  if (type == types[j].first) {
1460  if(vptr)
1461  *vptr = types[j].second.ptr;
1462  return SWIG_OK;
1463  }
1464  for (unsigned int j = 0; j < types.size(); ++j) {
1465  swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1466  if (!tc)
1467  continue;
1468  if(vptr) {
1469  int newmemory = 0;
1470  *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1471  if (newmemory == SWIG_CAST_NEW_MEMORY) {
1472  assert(_own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1473  if (_own)
1474  *_own = *_own | SWIG_CAST_NEW_MEMORY;
1475  }
1476  }
1477  res = SWIG_OK;
1478  break;
1479  }
1480  return res;
1481  }
1482 
1483  bool is_owned() const {
1484  return own;
1485  }
1486 
1487 #ifdef SWIG_DIRECTORS
1488  void director_destroyed(Swig::Director *d) {
1489  bool found = false;
1490  for (unsigned int j = 0; j < types.size(); ++j) {
1491  Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1492  if (dj == d) {
1493  types[j].second.destroyed = true;
1494  found = true;
1495  }
1496  }
1497  assert(found);
1498  }
1499 #endif
1500 
1501  void assign(const std::string &name, const octave_value &ov) {
1502  members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1503  }
1504 
1505  void assign(const std::string &name, const swig_octave_member *m) {
1506  members[name] = std::make_pair(m, octave_value());
1507  }
1508 
1509  octave_base_value *clone() const {
1510  // pass-by-value is probably not desired, and is harder;
1511  // requires calling copy constructors of contained types etc.
1512  assert(0);
1513  *(int *) 0 = 0;
1514  return 0;
1515  }
1516 
1517  octave_base_value *empty_clone() const {
1518  return new octave_swig_type();
1519  }
1520 
1521  bool is_defined() const {
1522  return true;
1523  }
1524 
1525  virtual bool is_map() const {
1526  return true;
1527  }
1528 
1529  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1530  octave_value_list ovl = subsref(ops, idx, 1);
1531  return ovl.length()? ovl(0) : octave_value();
1532  }
1533 
1534  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1535  assert(ops.size() > 0);
1536  assert(ops.size() == idx.size());
1537 
1538  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1539  int skip = 0;
1540  octave_value_list sub_ovl;
1541 
1542  // constructor invocation
1543  if (ops[skip] == '(' && construct_type) {
1544  assert(construct_type->clientdata);
1546  if (!c->constructor) {
1547  error("cannot create instance");
1548  return octave_value_list();
1549  }
1550  octave_value_list args;
1551  if (c->director)
1552  args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1553  args.append(*idx_it++);
1554  ++skip;
1555  sub_ovl = c->constructor(args, nargout);
1556  }
1557  // member dereference or invocation
1558  else if (ops[skip] == '.') {
1559  std::string subname;
1560  const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1561  for (;;) {
1562  octave_value_list subname_ovl(*idx_it++);
1563  ++skip;
1564  assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1565  subname = subname_ovl(0).string_value();
1566 
1567  const swig_type_info *next_base = find_base(subname, base);
1568  if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1569  break;
1570  base = next_base;
1571  }
1572 
1573  member_value_pair tmp, *m = &tmp;
1574  if (!base || !(m->first = find_member(base, subname)))
1575  m = find_member(subname, false);
1576  if (!m) {
1577  error("member not found");
1578  return octave_value_list();
1579  }
1580 
1581  octave_value_list args;
1582  if (!always_static &&
1583  (!m->first || (!m->first->is_static() && !m->first->is_global())))
1584  args.append(as_value());
1585  if (skip < (int) ops.size() && ops[skip] == '(' &&
1586  ((m->first && m->first->method) || m->second.is_function() ||
1587  m->second.is_function_handle())) {
1588  args.append(*idx_it++);
1589  ++skip;
1590  sub_ovl = member_invoke(m, args, nargout);
1591  } else {
1592  sub_ovl = member_deref(m, args);
1593  }
1594  }
1595  // index operator
1596  else {
1597  if (ops[skip] == '(' || ops[skip] == '{') {
1598  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1599  octave_value_list args;
1600  args.append(*idx_it++);
1601  ++skip;
1602  if (!dispatch_index_op(op_name, args, sub_ovl)) {
1603  error("error evaluating index operator");
1604  return octave_value_list();
1605  }
1606  } else {
1607  error("unsupported subsref");
1608  return octave_value_list();
1609  }
1610  }
1611 
1612  if (skip >= (int) ops.size())
1613  return sub_ovl;
1614  if (sub_ovl.length() < 1) {
1615  error("bad subs ref");
1616  return octave_value_list();
1617  }
1618  return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1619  }
1620 
1621  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1622  assert(ops.size() > 0);
1623  assert(ops.size() == idx.size());
1624 
1625  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1626  int skip = 0;
1627 
1628  if (ops.size() > 1) {
1629  std::list < octave_value_list >::const_iterator last = idx.end();
1630  --last;
1631  std::list < octave_value_list > next_idx(idx.begin(), last);
1632  octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1633  next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1634  }
1635 
1636  else if (ops[skip] == '(' || ops[skip] == '{') {
1637  const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1638  member_value_pair *m = find_member(op_name, false);
1639  if (m) {
1640  octave_value_list args;
1641  args.append(as_value());
1642  args.append(*idx_it);
1643  args.append(rhs);
1644  member_invoke(m, args, 1);
1645  } else
1646  error("%s member not found", op_name);
1647  }
1648 
1649  else if (ops[skip] == '.') {
1650  octave_value_list subname_ovl(*idx_it++);
1651  ++skip;
1652  assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1653  std::string subname = subname_ovl(0).string_value();
1654 
1655  member_value_pair *m = find_member(subname, true);
1656  if (!m->first || !m->first->set_method) {
1657  m->first = 0;
1658  m->second = rhs;
1659  } else if (m->first->set_method) {
1660  octave_value_list args;
1661  if (!m->first->is_static() && !m->first->is_global())
1662  args.append(as_value());
1663  args.append(rhs);
1664  m->first->set_method(args, 1);
1665  } else
1666  error("member not assignable");
1667  } else
1668  error("unsupported subsasgn");
1669 
1670  return as_value();
1671  }
1672 
1673  virtual bool is_object() const {
1674  return true;
1675  }
1676 
1677  virtual bool is_string() const {
1678  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1679  return !!nc_this->find_member("__str__", false);
1680  }
1681 
1682  virtual std::string string_value(bool force = false) const {
1683  octave_value ret;
1684  if (!dispatch_unary_op("__str__", ret)) {
1685  error("__str__ method not defined");
1686  return std::string();
1687  }
1688  if (!ret.is_string()) {
1689  error("__str__ method did not return a string");
1690  return std::string();
1691  }
1692  return ret.string_value();
1693  }
1694 
1695  virtual double scalar_value(bool frc_str_conv = false) const {
1696  octave_value ret;
1697  if (!dispatch_unary_op("__float__", ret)) {
1698  error("__float__ method not defined");
1699  }
1700  return ret.scalar_value();
1701  }
1702 
1703 #if SWIG_OCTAVE_PREREQ(4,2,0)
1704  virtual octave_value as_double(void) const {
1705  octave_value ret;
1706  if (!dispatch_unary_op("__float__", ret)) {
1707  error("__float__ method not defined");
1708  }
1709  return ret.as_double();
1710  }
1711 
1712  virtual octave_value as_single(void) const {
1713  octave_value ret;
1714  if (!dispatch_unary_op("__float__", ret)) {
1715  error("__float__ method not defined");
1716  }
1717  return ret.as_single();
1718  }
1719 #endif
1720 
1721 #if SWIG_OCTAVE_PREREQ(3,8,0)
1722  virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
1723  const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
1724  octave_value ret;
1725  if (!dispatch_unary_op(opname, ret)) {
1726  error("%s", (opname + std::string(" method not found")).c_str());
1727  return octave_value();
1728  }
1729  return ret;
1730  }
1731 #endif
1732 
1733 #if SWIG_OCTAVE_PREREQ(3,3,52)
1734  virtual octave_map map_value() const {
1735  return octave_map();
1736  }
1737 #else
1738  virtual Octave_map map_value() const {
1739  return Octave_map();
1740  }
1741 #endif
1742 
1743  virtual string_vector map_keys() const {
1744  member_map tmp;
1745  load_members(tmp);
1746 
1747  string_vector keys(tmp.size());
1748  int k = 0;
1749  for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1750  keys(k++) = it->first;
1751 
1752  return keys;
1753  }
1754 
1755  virtual bool save_ascii (std::ostream& os) {
1756  return true;
1757  }
1758 
1759  virtual bool load_ascii (std::istream& is) {
1760  return true;
1761  }
1762 
1763  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1764  return true;
1765  }
1766 
1767  virtual bool load_binary (std::istream& is, bool swap,
1768  oct_mach_info::float_format fmt) {
1769  return true;
1770  }
1771 
1772 #if defined (HAVE_HDF5)
1773 # if SWIG_OCTAVE_PREREQ(4,0,0)
1774  virtual bool
1775  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
1776  return true;
1777  }
1778 
1779  virtual bool
1780  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
1781  return true;
1782  }
1783 # else
1784  virtual bool
1785  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1786  return true;
1787  }
1788 
1789  virtual bool
1790  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1791  return true;
1792  }
1793 # endif
1794 #endif
1795 
1796  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1797  return string_value();
1798  }
1799 
1800  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1801  return string_value();
1802  }
1803 
1804  static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1805  // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1806  // (rather than any module namespace).
1807 
1808  octave_function *fcn = is_valid_function(symbol, std::string(), false);
1809  if (!fcn)
1810  return false;
1811 #if SWIG_OCTAVE_PREREQ(4,4,0)
1812  octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1813  octave_value_list retval = fcn->call(tw, 1, args);
1814  if (retval.length() == 1)
1815  ret = retval(0);
1816 #else
1817  ret = fcn->do_multi_index_op(1, args)(0);
1818 #endif
1819  return true;
1820  }
1821 
1822  static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1824  assert(ost);
1825 
1826  octave_value ret;
1827  if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1828  return ret;
1829  std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1830  octave_value_list args;
1831  args.append(make_value_hack(x));
1832  if (dispatch_global_op(symbol, args, ret))
1833  return ret;
1834 
1835  error("could not dispatch unary operator");
1836  return octave_value();
1837  }
1838 
1839  static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1840  octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
1841  octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
1842 
1843  octave_value ret;
1844  if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1845  return ret;
1846  if (rhs_ost) {
1847  if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1848  if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1849  return ret;
1850  if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1851  return ret;
1852  }
1853  if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1854  return ret;
1855  }
1856 
1857  std::string symbol;
1858  octave_value_list args;
1859  args.append(make_value_hack(lhs));
1860  args.append(make_value_hack(rhs));
1861 
1862  symbol = SWIG_op_prefix;
1863  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1864  symbol += "_";
1865  symbol += op_name;
1866  symbol += "_";
1867  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1868  if (dispatch_global_op(symbol, args, ret))
1869  return ret;
1870 
1871  symbol = SWIG_op_prefix;
1872  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1873  symbol += "_";
1874  symbol += op_name;
1875  symbol += "_";
1876  symbol += "any";
1877  if (dispatch_global_op(symbol, args, ret))
1878  return ret;
1879 
1880  symbol = SWIG_op_prefix;
1881  symbol += "any";
1882  symbol += "_";
1883  symbol += op_name;
1884  symbol += "_";
1885  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1886  if (dispatch_global_op(symbol, args, ret))
1887  return ret;
1888 
1889  error("could not dispatch binary operator");
1890  return octave_value();
1891  }
1892 
1893 #if SWIG_OCTAVE_PREREQ(4,0,0)
1894  void print(std::ostream &os, bool pr_as_read_syntax = false)
1895 #else
1896  void print(std::ostream &os, bool pr_as_read_syntax = false) const
1897 #endif
1898  {
1899  if (is_string()) {
1900  os << string_value();
1901  return;
1902  }
1903 
1904  member_map tmp;
1905  load_members(tmp);
1906 
1907  indent(os);
1908  os << "{"; newline(os);
1909  increment_indent_level();
1910  for (unsigned int j = 0; j < types.size(); ++j) {
1911  indent(os);
1912  if (types[j].first->clientdata) {
1913  const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1914  os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1915  } else {
1916  os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1917  }
1918  }
1919  for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1920  indent(os);
1921  if (it->second.first) {
1922  const char *objtype = it->second.first->method ? "method" : "variable";
1923  const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1924  os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1925  assert(it->second.first->name == it->first);
1926  } else {
1927  os << it->first; newline(os);
1928  }
1929  }
1930  decrement_indent_level();
1931  indent(os);
1932  os << "}"; newline(os);
1933  }
1934  };
1935 
1936  // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1937  // will call clone() via make_unique() if there is more than one outstanding
1938  // reference to the lhs, and forces the clone's reference count to 1
1939  // (so you can't just increment your own count and return this).
1940  //
1941  // One way to fix this (without modifying Octave) is to add a level of
1942  // indirection such that clone copies ref-counted pointer and we keep
1943  // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1944  //
1945  // Supporting both pass-by-{ref,value} and toggling via %feature/option
1946  // might be nice.
1947 
1948  class octave_swig_ref:public octave_base_value {
1950  public:
1952  :ptr(_ptr)
1953  {
1954  // Ensure type_id() is set correctly
1955  if (t_id == -1) {
1956  t_id = octave_swig_ref::static_type_id();
1957  }
1958  }
1959 
1961  { if (ptr) ptr->decref(); }
1962 
1964  { return ptr; }
1965 
1966  octave_base_value *clone() const
1967  { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
1968 
1969  octave_base_value *empty_clone() const
1970  { return new octave_swig_ref(0); }
1971 
1972  dim_vector dims(void) const
1973  { return ptr->dims(); }
1974 
1975  bool is_defined() const
1976  { return ptr->is_defined(); }
1977 
1978  virtual bool is_map() const
1979  { return ptr->is_map(); }
1980 
1981  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
1982  { return ptr->subsref(ops, idx); }
1983 
1984  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
1985  { return ptr->subsref(ops, idx, nargout); }
1986 
1987  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
1988  { return ptr->subsasgn(ops, idx, rhs); }
1989 
1990  virtual bool is_object() const
1991  { return ptr->is_object(); }
1992 
1993  virtual bool is_string() const
1994  { return ptr->is_string(); }
1995 
1996  virtual std::string string_value(bool force = false) const
1997  { return ptr->string_value(force); }
1998 
1999  virtual double scalar_value(bool frc_str_conv = false) const
2000  { return ptr->scalar_value(frc_str_conv); }
2001 
2002 #if SWIG_OCTAVE_PREREQ(4,2,0)
2003  virtual octave_value as_double(void) const
2004  { return ptr->as_double(); }
2005 
2006  virtual octave_value as_single(void) const
2007  { return ptr->as_single(); }
2008 #endif
2009 
2010 #if SWIG_OCTAVE_PREREQ(3,8,0)
2011  virtual octave_value map(octave_base_value::unary_mapper_t umap) const
2012  { return ptr->map(umap); }
2013 #endif
2014 
2015 #if SWIG_OCTAVE_PREREQ(3,3,52)
2016  virtual octave_map map_value() const
2017  { return ptr->map_value(); }
2018 #else
2019  virtual Octave_map map_value() const
2020  { return ptr->map_value(); }
2021 #endif
2022 
2023  virtual string_vector map_keys() const
2024  { return ptr->map_keys(); }
2025 
2026  virtual bool save_ascii (std::ostream& os)
2027  { return ptr->save_ascii(os); }
2028 
2029  virtual bool load_ascii (std::istream& is)
2030  { return ptr->load_ascii(is); }
2031 
2032  virtual bool save_binary (std::ostream& os, bool& save_as_floats)
2033  { return ptr->save_binary(os, save_as_floats); }
2034 
2035  virtual bool load_binary (std::istream& is, bool swap,
2036  oct_mach_info::float_format fmt)
2037  { return ptr->load_binary(is, swap, fmt); }
2038 
2039 #if defined (HAVE_HDF5)
2040 # if SWIG_OCTAVE_PREREQ(4,0,0)
2041  virtual bool
2042  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
2043  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2044 
2045  virtual bool
2046  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
2047  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2048 # else
2049  virtual bool
2050  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
2051  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2052 
2053  virtual bool
2054  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
2055  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2056 # endif
2057 #endif
2058 
2059  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
2060  { return ptr->convert_to_str(pad, force, type); }
2061 
2062  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
2063  { return ptr->convert_to_str_internal(pad, force, type); }
2064 
2065 #if SWIG_OCTAVE_PREREQ(4,0,0)
2066  void print(std::ostream &os, bool pr_as_read_syntax = false)
2067 #else
2068  void print(std::ostream &os, bool pr_as_read_syntax = false) const
2069 #endif
2070  { return ptr->print(os, pr_as_read_syntax); }
2071 
2072  virtual type_conv_info numeric_conversion_function(void) const {
2073  return octave_base_value::type_conv_info (default_numeric_conversion_function,
2074  octave_scalar::static_type_id ());
2075  }
2076 
2077  private:
2078  static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
2079  const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
2080  return new octave_scalar(v.scalar_value());
2081  }
2082 
2083 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2085 #endif
2087  };
2088 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2090 #endif
2092 
2093  class octave_swig_packed:public octave_base_value {
2095  std::vector < char > buf;
2096  public:
2097 
2098  octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
2099  : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len)
2100  {
2101  // Ensure type_id() is set correctly
2102  if (t_id == -1) {
2103  t_id = octave_swig_packed::static_type_id();
2104  }
2105  }
2106 
2107  bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
2108  if (outtype && outtype != type)
2109  return false;
2110  assert(sz <= buf.size());
2111  std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
2112  return true;
2113  }
2114 
2115  octave_base_value *clone() const {
2116  return new octave_swig_packed(*this);
2117  }
2118 
2119  octave_base_value *empty_clone() const {
2120  return new octave_swig_packed();
2121  }
2122 
2123  bool is_defined() const {
2124  return true;
2125  }
2126 
2127 #if SWIG_OCTAVE_PREREQ(4,0,0)
2128  void print(std::ostream &os, bool pr_as_read_syntax = false)
2129 #else
2130  void print(std::ostream &os, bool pr_as_read_syntax = false) const
2131 #endif
2132  {
2133  indent(os);
2134  os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
2135  }
2136 
2137 
2138  virtual bool save_ascii (std::ostream& os) {
2139  return true;
2140  }
2141 
2142  virtual bool load_ascii (std::istream& is) {
2143  return true;
2144  }
2145 
2146  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
2147  return true;
2148  }
2149 
2150  virtual bool load_binary (std::istream& is, bool swap,
2151  oct_mach_info::float_format fmt) {
2152  return true;
2153  }
2154 
2155 #if defined (HAVE_HDF5)
2156 # if SWIG_OCTAVE_PREREQ(4,0,0)
2157  virtual bool
2158  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
2159  return true;
2160  }
2161 
2162  virtual bool
2163  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
2164  return true;
2165  }
2166 # else
2167  virtual bool
2168  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
2169  return true;
2170  }
2171 
2172  virtual bool
2173  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
2174  return true;
2175  }
2176 # endif
2177 #endif
2178 
2179  private:
2180 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2182 #endif
2184  };
2185 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2187 #endif
2189 
2190  SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
2191  error("attempt to set immutable member variable");
2192  return octave_value_list();
2193  }
2194 
2196  const octave_value_list &ovl;
2197  int j;
2198 
2199  octave_value_ref(const octave_value_list &_ovl, int _j)
2200  :ovl(_ovl), j(_j) { }
2201 
2202  operator octave_value() const {
2203  return ovl(j);
2204  }
2205 
2206  octave_value operator*() const {
2207  return ovl(j);
2208  }
2209  };
2210 
2211 
2212 namespace Swig {
2213 
2214  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
2215  return new octave_swig_ref(ost);
2216  }
2217 
2219  if (
2220 #if SWIG_OCTAVE_PREREQ(4,4,0)
2221  ov.iscell()
2222 #else
2223  ov.is_cell()
2224 #endif
2225  && ov.rows() == 1 && ov.columns() == 1)
2226  ov = ov.cell_value()(0);
2227  return swig_value_deref(*ov.internal_rep());
2228  }
2229 
2230  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
2231  if (ov.type_id() != octave_swig_ref::static_type_id())
2232  return 0;
2233  const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2234  return osr->get_ptr();
2235  }
2236 
2237 }
2238 
2239 
2240 #define swig_unary_op(name) \
2241 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2242  return octave_swig_type::dispatch_unary_op(x,#name); \
2243 }
2244 #define swig_binary_op(name) \
2245 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2246  return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2247 }
2248 #if SWIG_OCTAVE_PREREQ(4,4,0)
2249 #define swigreg_unary_op(name) \
2250 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2251 typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2252 #else
2253 #define swigreg_unary_op(name) \
2254 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2255 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2256 #endif
2257 #if SWIG_OCTAVE_PREREQ(4,4,0)
2258 #define swigreg_binary_op(name) \
2259 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2260 typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2261 #else
2262 #define swigreg_binary_op(name) \
2263 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2264 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2265 #endif
2266 
2269  swig_unary_op(uminus);
2270  swig_unary_op(transpose);
2271  swig_unary_op(hermitian);
2274 
2281 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2284 #endif
2294  swig_binary_op(el_ldiv);
2297 
2299 #if SWIG_OCTAVE_PREREQ(4,4,0)
2300  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2301 #endif
2302  swigreg_unary_op(not);
2303  swigreg_unary_op(uplus);
2304  swigreg_unary_op(uminus);
2305  swigreg_unary_op(transpose);
2306  swigreg_unary_op(hermitian);
2307  swigreg_unary_op(incr);
2308  swigreg_unary_op(decr);
2309  }
2310  SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2311 #if SWIG_OCTAVE_PREREQ(4,4,0)
2312  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2313 #endif
2314  swigreg_binary_op(add);
2315  swigreg_binary_op(sub);
2316  swigreg_binary_op(mul);
2317  swigreg_binary_op(div);
2318  swigreg_binary_op(pow);
2319  swigreg_binary_op(ldiv);
2320 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2321  swigreg_binary_op(lshift);
2322  swigreg_binary_op(rshift);
2323 #endif
2324  swigreg_binary_op(lt);
2325  swigreg_binary_op(le);
2326  swigreg_binary_op(eq);
2327  swigreg_binary_op(ge);
2328  swigreg_binary_op(gt);
2329  swigreg_binary_op(ne);
2330  swigreg_binary_op(el_mul);
2331  swigreg_binary_op(el_div);
2332  swigreg_binary_op(el_pow);
2333  swigreg_binary_op(el_ldiv);
2334  swigreg_binary_op(el_and);
2335  swigreg_binary_op(el_or);
2336  }
2338  // here we assume that tid are conseq integers increasing from zero, and
2339  // that our tid is the last one. might be better to have explicit string
2340  // list of types we should bind to, and use lookup_type to resolve their tid.
2341 
2342  SWIG_InstallUnaryOps(tid);
2343  SWIG_InstallBinaryOps(tid, tid);
2344  for (int j = 0; j < tid; ++j) {
2345  SWIG_InstallBinaryOps(j, tid);
2346  SWIG_InstallBinaryOps(tid, j);
2347  }
2348  }
2349 
2350 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2351  int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2352 
2353 #ifdef SWIG_DIRECTORS
2354  Swig::Director *d = Swig::get_rtdir(ptr);
2355  if (d && Swig::swig_director_get_self(d))
2356  return Swig::swig_director_get_self(d)->as_value();
2357 #endif
2358  return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2359 }
2360 
2361 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2362  if (
2363 #if SWIG_OCTAVE_PREREQ(4,4,0)
2364  ov.iscell()
2365 #else
2366  ov.is_cell()
2367 #endif
2368  && ov.rows() == 1 && ov.columns() == 1)
2369  ov = ov.cell_value()(0);
2370  if (!ov.is_defined() ||
2371  (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2372  if (ptr)
2373  *ptr = 0;
2375  }
2376  if (ov.type_id() != octave_swig_ref::static_type_id())
2377  return SWIG_ERROR;
2378  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2379  octave_swig_type *ost = osr->get_ptr();
2380  return ost->cast(ptr, type, own, flags);
2381 }
2382 
2383 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2384  return new octave_swig_packed(type, (char *) ptr, sz);
2385 }
2386 
2387 SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2388  if (!ov.is_defined())
2389  return SWIG_ERROR;
2390  if (ov.type_id() != octave_swig_packed::static_type_id())
2391  return SWIG_ERROR;
2392  octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2393  return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2394 }
2395 
2396 SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2397  module_ns->assign(name, ov);
2398 }
2399 
2401 #if SWIG_OCTAVE_PREREQ(4,4,0)
2402  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2403  return symtab.global_varval(name);
2404 #else
2405  return get_global_value(name, true);
2406 #endif
2407 }
2408 
2409 SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2410 #if SWIG_OCTAVE_PREREQ(4,4,0)
2411  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2412  symtab.global_assign(name, value);
2413 #else
2414  set_global_value(name, value);
2415 #endif
2416 }
2417 
2419 #if SWIG_OCTAVE_PREREQ(4,4,0)
2420  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2421  octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2422  symscope.assign(name, symtab.global_varval(name));
2423  symscope.mark_global(name);
2424 #else
2425 #if !SWIG_OCTAVE_PREREQ(3,2,0)
2426  link_to_global_variable(curr_sym_tab->lookup(name, true));
2427 #else
2428 #if !SWIG_OCTAVE_PREREQ(3,8,0)
2429  symbol_table::varref(name);
2430 #endif
2431  symbol_table::mark_global(name);
2432 #endif
2433 #endif
2434 }
2435 
2437  octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2438  if (!ov.is_defined() ||
2439  ov.type_id() != octave_swig_packed::static_type_id())
2440  return 0;
2441  const octave_swig_packed* osp =
2442  static_cast < const octave_swig_packed *> (ov.internal_rep());
2443  swig_module_info *pointer = 0;
2444  osp->copy(0, &pointer, sizeof(swig_module_info *));
2445  return pointer;
2446 }
2447 
2448 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2449  octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2451 }
2452 
2453 
2454 
2455 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2456 
2457 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2458 
2459 
2460 
2461 /* -------- TYPES TABLE (BEGIN) -------- */
2462 
2463 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2464 #define SWIGTYPE_p_char swig_types[1]
2465 #define SWIGTYPE_p_double swig_types[2]
2466 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2467 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2468 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2469 #define SWIGTYPE_p_int swig_types[6]
2470 #define SWIGTYPE_p_p_char swig_types[7]
2471 #define SWIGTYPE_p_unsigned_int swig_types[8]
2473 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2474 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2475 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2476 
2477 /* -------- TYPES TABLE (END) -------- */
2478 
2479 
2480 #define SWIGVERSION 0x040002
2481 #define SWIG_VERSION SWIGVERSION
2482 
2483 
2484 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2485 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2486 
2487 
2488 #include <stdexcept>
2489 
2490 
2491 // #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2492 #undef PACKAGE
2493 #undef VERSION
2494 
2495 #include "plplotP.h"
2496 
2497 // Temporary fix for problems with -fvisibility=hidden and octave headers.
2498 #ifdef OCTAVE_EXPORT
2499  #if defined ( __GNUC__ ) && __GNUC__ > 3
2500  #undef OCTAVE_EXPORT
2501  #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2502  #endif
2503 #endif
2504 
2505 
2506 
2507 // I hate global variables but this is the best way I can think of
2508 // to manage consistency checking among function arguments.
2509  static PLINT Alen = 0;
2510  static PLINT Xlen = 0, Ylen = 0;
2511 
2512 
2513 // Convenience functions copied from matwrap-based approach (currently
2514 // stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2515 // tricky scalar case and also adopted so that the resulting
2516 // swig-generated source code will look similar to the matwrap-generated
2517 // source code.
2518 
2519  inline int max( int a, int b )
2520  {
2521  return a >= b ? a : b;
2522  }
2523  inline int min( int a, int b )
2524  {
2525  return a >= b ? a : b;
2526  }
2527 
2528 //
2529 // Function to get the total length (rows*columns) of an octave object of
2530 // arbitrary type.
2531 // Arguments:
2532 // 1) The octave object.
2533 //
2534 // If the object is a scalar, the array length is 1.
2535 //
2536  static int
2537  _arraylen( const octave_value &o_obj )
2538  {
2539  return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2540  // max is necessary because sometimes
2541  // rows() or columns() return -1 or 0 for
2542  // scalars.
2543  }
2544 
2545 //
2546 // Function to get the number of dimensions of an object.
2547 //
2548  static int
2549  _n_dims( const octave_value &o_obj )
2550  {
2551  if ( max( o_obj.columns(), 1 ) > 1 )
2552  return 2;
2553  // max is necessary because sometimes
2554  // rows() or columns() return -1 or 0 for
2555  // scalars.
2556  else if ( max( o_obj.rows(), 1 ) > 1 )
2557  return 1;
2558  else
2559  return 0;
2560  }
2561 
2562 //
2563 // Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2564 //
2565  static inline int
2566  _dim( const octave_value &o_obj, int dim_idx )
2567  {
2568  if ( dim_idx == 0 )
2569  return max( o_obj.rows(), 0 );
2570  // max is necessary because sometimes
2571  // rows() or columns() return -1 or 0 for
2572  // scalars.
2573  else if ( dim_idx == 1 )
2574  return max( o_obj.columns(), 0 );
2575  else
2576  return 1;
2577  }
2578 
2579 //
2580 // The following function converts an array of doubles into some other
2581 // numeric type. Arguments:
2582 // 1) Where to store the result. The type is determined from the type of
2583 // this pointer.
2584 // 2) A vector of doubles to convert.
2585 // 3) The number of doubles.
2586 //
2587  template <class FLOAT>
2588  static inline void
2589  _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2590  {
2591  while ( n_el-- > 0 )
2592  *out_arr++ = (FLOAT) ( *in_arr++ );
2593  }
2594 
2595  template void _cvt_double_to( int *, double *, unsigned );
2596  template void _cvt_double_to( unsigned *, double *, unsigned );
2597  template void _cvt_double_to( long *, double *, unsigned );
2598  template void _cvt_double_to( unsigned long *, double *, unsigned );
2599  template void _cvt_double_to( short *, double *, unsigned );
2600  template void _cvt_double_to( unsigned short *, double *, unsigned );
2601  template void _cvt_double_to( float *, double *, unsigned );
2602  // Instantiate our templates. Octave uses
2603  // manual template instantiation.
2604 
2605 //
2606 // Convert an array of some other type into an array of doubles. Arguments:
2607 // 1) The array of objects of other type.
2608 // 2) The output array of doubles.
2609 // 3) The number of elements to convert.
2610 //
2611  template <class FLOAT>
2612  static inline void
2613  _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2614  {
2615  while ( n_el-- > 0 )
2616  *d_arr++ = double(*arr++);
2617  }
2618 
2619  template void _cvt_to_double( int *, double *, unsigned );
2620  template void _cvt_to_double( unsigned *, double *, unsigned );
2621  template void _cvt_to_double( long *, double *, unsigned );
2622  template void _cvt_to_double( unsigned long *, double *, unsigned );
2623  template void _cvt_to_double( short *, double *, unsigned );
2624  template void _cvt_to_double( unsigned short *, double *, unsigned );
2625  template void _cvt_to_double( float *, double *, unsigned );
2626  // Instantiate our templates. Octave uses
2627  // manual template instantiation.
2628 
2629 
2630  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2631  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2632  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2633  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2634  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2636  typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2637 
2638 
2639 #include <iostream>
2640 
2641  octave_function *fcnMapForm;
2642  std::string nameMapForm;
2643 
2644  void mapform_octave( PLINT n, PLFLT *x, PLFLT *y )
2645  {
2646  octave_idx_type i;
2647  octave_value_list functionArguments;
2648  octave_value_list retval;
2649 
2650  Matrix xin( n, 1 );
2651  Matrix yin( n, 1 );
2652  Matrix xout;
2653  Matrix yout;
2654 
2655  for ( i = 0; i < n; i++ )
2656  {
2657  xin( i, 0 ) = x[i];
2658  yin( i, 0 ) = y[i];
2659  }
2660 
2661  functionArguments( 0 ) = xin;
2662  functionArguments( 1 ) = yin;
2663 
2664  if ( fcnMapForm != NULL )
2665 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2666  retval = octave::feval( fcnMapForm, functionArguments, 1 );
2667 #else
2668  retval = feval( fcnMapForm, functionArguments, 1 );
2669 #endif
2670  else
2671 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2672  retval = octave::feval( nameMapForm, functionArguments, 1 );
2673 #else
2674  retval = feval( nameMapForm, functionArguments, 1 );
2675 #endif
2676 
2677  if ( retval.length() >= 2 )
2678  {
2679  xout = retval( 0 ).matrix_value();
2680  yout = retval( 1 ).matrix_value();
2681 
2682  for ( i = 0; i < n; i++ )
2683  {
2684  x[i] = xout( i, 0 );
2685  y[i] = yout( i, 0 );
2686  }
2687  }
2688  }
2689 
2690 
2691  octave_function *fcnLabelFunc;
2692  std::string nameLabelFunc;
2693 
2694  void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2695  {
2696  int i;
2697  octave_value_list functionArguments;
2698  octave_value_list retval;
2699 
2700  Matrix inAxis( 1, 1 );
2701  Matrix inValue( 1, 1 );
2702  inAxis( 0, 0 ) = axis;
2703  inValue( 0, 0 ) = value;
2704 
2705  functionArguments( 0 ) = inAxis;
2706  functionArguments( 1 ) = inValue;
2707 
2708  if ( fcnLabelFunc != NULL )
2709 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2710  retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2711 #else
2712  retval = feval( fcnLabelFunc, functionArguments, 1 );
2713 #endif
2714  else
2715 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2716  retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2717 #else
2718  retval = feval( nameLabelFunc, functionArguments, 1 );
2719 #endif
2720 
2721  strncpy( label, retval( 0 ).string_value().c_str(), length );
2722  }
2723 
2724 
2725  octave_function *fcnCoordTrans;
2726  std::string nameCoordTrans;
2727 
2728  void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2729  {
2730  octave_idx_type i;
2731  octave_value_list functionArguments;
2732  octave_value_list retval;
2733 
2734  Matrix xin( 1, 1 );
2735  Matrix yin( 1, 1 );
2736  Matrix xout;
2737  Matrix yout;
2738 
2739  xin( 0, 0 ) = x;
2740  yin( 0, 0 ) = y;
2741 
2742  functionArguments( 0 ) = xin;
2743  functionArguments( 1 ) = yin;
2744 
2745  if ( fcnCoordTrans != NULL )
2746 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2747  retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2748 #else
2749  retval = feval( fcnCoordTrans, functionArguments, 1 );
2750 #endif
2751  else
2752 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2753  retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2754 #else
2755  retval = feval( nameCoordTrans, functionArguments, 1 );
2756 #endif
2757 
2758  if ( retval.length() >= 2 )
2759  {
2760  xout = retval( 0 ).matrix_value();
2761  yout = retval( 1 ).matrix_value();
2762 
2763  *xt = xout( 0, 0 );
2764  *yt = yout( 0, 0 );
2765  }
2766  }
2767 
2768 
2769  void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2770  {
2771  PLINT i;
2772  printf( "nlegend =%d\n", nlegend );
2773  for ( i = 0; i < nlegend; i++ )
2774  {
2775  printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2776  printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2777  printf( "text[%d] =%s\n", i, text[i] );
2778  }
2779  }
2780 
2781 
2782 #include <limits.h>
2783 #if !defined(SWIG_NO_LLONG_MAX)
2784 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2785 # define LLONG_MAX __LONG_LONG_MAX__
2786 # define LLONG_MIN (-LLONG_MAX - 1LL)
2787 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2788 # endif
2789 #endif
2790 
2791 
2792  SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2793  {
2794  if (!ov.is_scalar_type())
2795  return SWIG_TypeError;
2796  if (ov.is_complex_scalar())
2797  return SWIG_TypeError;
2798  if (ov.is_double_type()||ov.is_single_type()) {
2799  double v=ov.double_value();
2800  if (v!=floor(v))
2801  return SWIG_TypeError;
2802  }
2803  if (val)
2804  *val = ov.long_value();
2805  return SWIG_OK;
2806  }
2807 
2808 
2809 SWIGINTERN int
2810 SWIG_AsVal_int (octave_value obj, int *val)
2811 {
2812  long v;
2813  int res = SWIG_AsVal_long (obj, &v);
2814  if (SWIG_IsOK(res)) {
2815  if ((v < INT_MIN || v > INT_MAX)) {
2816  return SWIG_OverflowError;
2817  } else {
2818  if (val) *val = static_cast< int >(v);
2819  }
2820  }
2821  return res;
2822 }
2823 
2824 
2825  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 )
2826  {
2827  PLGraphicsIn gin;
2828  int status; status = plGetCursor( &gin );
2829  *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2830  strncpy( string, gin.string, PL_MAXKEY - 1 );
2831  string[PL_MAXKEY - 1] = '\0';
2832 
2833  *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2834  return status;
2835  }
2836 
2837 
2838 SWIGINTERN int
2839 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2840 {
2841  if (
2842 #if SWIG_OCTAVE_PREREQ(4,4,0)
2843  ov.iscell()
2844 #else
2845  ov.is_cell()
2846 #endif
2847  && ov.rows() == 1 && ov.columns() == 1)
2848  ov = ov.cell_value()(0);
2849  if (!ov.is_string())
2850  return SWIG_TypeError;
2851 
2852  std::string str=ov.string_value();
2853  size_t len=str.size();
2854  char* cstr=(char*)str.c_str();
2855  if (alloc) {
2856  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
2857  *alloc = SWIG_NEWOBJ;
2858  } else if (cptr)
2859  *cptr = cstr;
2860  if (psize)
2861  *psize = len + 1;
2862  return SWIG_OK;
2863 }
2864 
2865 
2866 
2867 
2868 
2870  {
2871  return octave_value(value);
2872  }
2873 
2874 
2875 SWIGINTERNINLINE octave_value
2877 {
2878  return SWIG_From_long (value);
2879 }
2880 
2881 
2883  {
2884  return octave_value(value);
2885  }
2886 
2887 
2888 // Translates relative device coordinates to world coordinates.
2889  static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2890  {
2891  PLGraphicsIn gin;
2892  int st;
2893  gin.dX = x_in; gin.dY = y_in;
2894  st = plTranslateCursor( &gin );
2895  *x = gin.wX; *y = gin.wY;
2896  return st;
2897  }
2898 
2899 
2900  SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2901  {
2902  if (!ov.is_scalar_type())
2903  return SWIG_TypeError;
2904  if (ov.is_complex_scalar())
2905  return SWIG_TypeError;
2906  if (val)
2907  *val = ov.double_value();
2908  return SWIG_OK;
2909  }
2910 
2911 
2912 // Create 1d stripchart
2913 
2914  void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
2915  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2916  PLFLT xlpos, PLFLT ylpos,
2917  PLBOOL y_ascl, PLBOOL acc,
2918  PLINT colbox, PLINT collab,
2919  const PLINT *colline, const PLINT *styline,
2920  const char *legline1, const char *legline2, const char *legline3, const char *legline4,
2921  const char *labx, const char *laby, const char *labtop )
2922  {
2923  const char *legline[4];
2924  legline[0] = legline1; legline[1] = legline2;
2925  legline[2] = legline3; legline[3] = legline4;
2926  c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2927  xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2928  labx, laby, labtop );
2929  }
2930 
2931 
2932 // One more hack. As it is not possible (and would not be desirable) to pass
2933 // an Octave function to plcont(), I have defined three plcont():
2934 // plcont uses a defined here xform()
2935 // plcont0 uses pltr0()
2936 // plcont1 uses pltr1()
2937 // plcont2 uses pltr2()
2938 // plcont2p uses pltr2p()
2939 //
2940 // Also, as plplot expect vectorized bidimensional arrays, I provided a
2941 // f2c, which is a #define that does the necessary conversion.
2942 //
2943 
2944  void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
2945  {
2946  *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2947  *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2948  }
2949 
2950 // convert from Fortran like arrays (one vector), to C like 2D arrays
2951 
2952 #define f2c( f, ff, nx, ny ) \
2953  PLFLT * *ff; \
2954  ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2955  for ( int i = 0; i < nx; i++ ) { \
2956  ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2957  for ( int j = 0; j < ny; j++ ) \
2958  *( ff[i] + j ) = *( f + nx * j + i );}
2959 
2960 // simpler plcont() for use with xform()
2961 
2962  void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2963  PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2964  {
2965  f2c( f, ff, nx, ny );
2966  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
2967  }
2968 
2969 // plcont() for use with pltr0() NOT TESTED
2970 
2971  void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2972  PLINT ly, const PLFLT *clevel, PLINT nlevel )
2973  {
2974  f2c( f, ff, nx, ny );
2975  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
2976  }
2977 
2978 // plcont() for use with pltr1()
2979 
2980  void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2981  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2982  {
2983  PLcGrid grid1;
2984  grid1.nx = nx; grid1.ny = ny;
2985  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2986  f2c( f, ff, nx, ny );
2987  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
2988  }
2989 
2990 // plcont() for use with pltr2()
2991  void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2992  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2993  {
2994  PLcGrid2 grid2;
2995  f2c( xg, xgg, nx, ny );
2996  f2c( yg, ygg, nx, ny );
2997  grid2.nx = nx; grid2.ny = ny;
2998  grid2.xg = xgg; grid2.yg = ygg;
2999  f2c( f, ff, nx, ny );
3000  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3001  }
3002 
3003 // plcont() for use with pltr2p()
3004 
3005  void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3006  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3007  {
3008  PLcGrid2 grid2;
3009  f2c( xg, xgg, nx, ny );
3010  f2c( yg, ygg, nx, ny );
3011  grid2.nx = nx; grid2.ny = ny;
3012  grid2.xg = xgg; grid2.yg = ygg;
3013  f2c( f, ff, nx, ny );
3014  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3015  }
3016 
3017 
3018  void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
3019  const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
3020  PLFLT *zg, int type, PLFLT data )
3021  {
3022  f2c( zg, zgg, nptsx, nptsy );
3023  plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3024  for ( int i = 0; i < nptsx; i++ )
3025  for ( int j = 0; j < nptsy; j++ )
3026  *( zg + nptsx * j + i ) = zgg[i][j];
3027  }
3028 
3029 
3030 // Plots a mesh representation of the function z[x][y].
3031 
3032  void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3033  {
3034  f2c( z, zz, nx, ny );
3035  c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3036  }
3037 
3038 // Plots a mesh representation of the function z[x][y] with contour
3039 
3040  void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3041  {
3042  f2c( z, zz, nx, ny );
3043  c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3044  }
3045 
3046 
3047 // Plots a 3-d representation of the function z[x][y].
3048  void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3049  PLINT nx, PLINT ny, PLINT opt, PLINT side )
3050  {
3051  f2c( z, zz, nx, ny );
3052  c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3053  }
3054 
3055 // Plots a 3-d representation of the function z[x][y] with contour
3056  void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3057  PLINT nx, PLINT ny, PLINT opt,
3058  const PLFLT *clevel, PLINT nlevel )
3059  {
3060  f2c( z, zz, nx, ny );
3061  c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3062  }
3063 // Plots a 3-d representation of the function z[x][y] with contour with y
3064 // index limits
3065  void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3066  PLINT nx, PLINT ny, PLINT opt,
3067  const PLFLT * clevel, PLINT nlevel,
3068  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3069  {
3070  f2c( z, zz, nx, ny );
3071  c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3072  indexxmin, indexxmax, indexymin, indexymax );
3073  }
3074 
3075 
3076  void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3077  PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3078  {
3079  f2c( z, zz, nx, ny );
3080  c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3081  }
3082 
3083  void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3084  PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3085  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3086  {
3087  f2c( z, zz, nx, ny );
3088  c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3089  indexxmin, indexxmax, indexymin, indexymax );
3090  }
3091 
3092 
3093 // The same as in plcont. I have hardcoded the first function pointer
3094 // to plfill(). The second function pointer will use the same convention
3095 // as in plcont().
3096 //
3097 
3098 // the simpler plshade()
3099  void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3100  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3101  PLFLT shade_min, PLFLT shade_max,
3102  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3103  PLINT min_color, PLINT min_width,
3104  PLINT max_color, PLINT max_width,
3105  PLINT rectangular, PLFLT *tr )
3106  {
3107  f2c( a, aa, nx, ny );
3108  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3109  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3110  min_color, min_width, max_color, max_width,
3111  plfill, rectangular, xform, tr );
3112  }
3113 
3114 // plshade() for use with pltr1
3115  void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3116  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3117  PLFLT shade_min, PLFLT shade_max,
3118  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3119  PLINT min_color, PLINT min_width,
3120  PLINT max_color, PLINT max_width,
3121  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3122  {
3123  PLcGrid grid1;
3124  grid1.nx = nx; grid1.ny = ny;
3125  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3126  f2c( a, aa, nx, ny );
3127  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3128  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3129  min_color, min_width, max_color, max_width,
3130  plfill, rectangular, pltr1, &grid1 );
3131  }
3132 
3133 // plshade() for use with pltr2
3134  void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3135  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3136  PLFLT shade_min, PLFLT shade_max,
3137  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3138  PLINT min_color, PLINT min_width,
3139  PLINT max_color, PLINT max_width,
3140  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3141  {
3142  PLcGrid2 grid2;
3143  f2c( xg, xgg, nx, ny );
3144  f2c( yg, ygg, nx, ny );
3145  grid2.nx = nx; grid2.ny = ny;
3146  grid2.xg = xgg; grid2.yg = ygg;
3147  f2c( a, aa, nx, ny );
3148  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3149  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3150  min_color, min_width, max_color, max_width,
3151  plfill, rectangular, pltr2, &grid2 );
3152  }
3153 
3154 
3155 
3156  void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3157  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3158  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3159  PLINT cont_color, PLINT cont_width,
3160  PLINT rectangular )
3161  {
3162  f2c( a, aa, nx, ny );
3163  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3164  clevel, nlevel, fill_width, cont_color, cont_width,
3165  plfill, rectangular, NULL, NULL );
3166  }
3167 
3168  void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3169  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3170  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3171  PLINT cont_color, PLINT cont_width,
3172  PLINT rectangular, PLFLT *tr )
3173  {
3174  f2c( a, aa, nx, ny );
3175  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3176  clevel, nlevel, fill_width, cont_color, cont_width,
3177  plfill, rectangular, xform, tr );
3178  }
3179 
3180  void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3181  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3182  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3183  PLINT cont_color, PLINT cont_width,
3184  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3185  {
3186  PLcGrid grid1;
3187  grid1.nx = nx; grid1.ny = ny;
3188  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3189 
3190  f2c( a, aa, nx, ny );
3191  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3192  clevel, nlevel, fill_width, cont_color, cont_width,
3193  plfill, rectangular, pltr1, &grid1 );
3194  }
3195 
3196  void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3197  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3198  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3199  PLINT cont_color, PLINT cont_width,
3200  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3201  {
3202  PLcGrid2 grid2;
3203  f2c( xg, xgg, nx, ny );
3204  f2c( yg, ygg, nx, ny );
3205  grid2.nx = nx; grid2.ny = ny;
3206  grid2.xg = xgg; grid2.yg = ygg;
3207  f2c( a, aa, nx, ny );
3208  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3209  clevel, nlevel, fill_width, cont_color, cont_width,
3210  plfill, rectangular, pltr2, &grid2 );
3211  }
3212 
3213 
3214 // Plot an array of vector arrows - uses the same function pointer
3215 // convention as plcont
3216 
3217  void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3218  {
3219  f2c( u, uu, nx, ny );
3220  f2c( v, vv, nx, ny );
3221  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3222  }
3223 
3224 // plvect() for use with pltr1
3225  void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3226  {
3227  PLcGrid grid1;
3228  grid1.nx = nx; grid1.ny = ny;
3229  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3230  f2c( u, uu, nx, ny );
3231  f2c( v, vv, nx, ny );
3232  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3233  }
3234 
3235 // plvect() for use with pltr2
3236  void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3237  {
3238  PLcGrid2 grid2;
3239  f2c( xg, xgg, nx, ny );
3240  f2c( yg, ygg, nx, ny );
3241  grid2.nx = nx; grid2.ny = ny;
3242  grid2.xg = xgg; grid2.yg = ygg;
3243  f2c( u, uu, nx, ny );
3244  f2c( v, vv, nx, ny );
3245  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3246  }
3247 
3248 
3249 // Plot an image with distortion - uses the same function pointer
3250  void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3251  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3252  PLFLT zmin, PLFLT zmax,
3253  PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3254  {
3255  f2c( a, aa, nx, ny );
3256  plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3257  }
3258 
3259 // Plot an image with distortion - uses the same function pointer
3260 // convention as plcont
3261  void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3262  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3263  PLFLT zmin, PLFLT zmax,
3264  PLFLT valuemin, PLFLT valuemax )
3265  {
3266  f2c( a, aa, nx, ny );
3267  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3268  }
3269 
3270  void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3271  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3272  PLFLT zmin, PLFLT zmax,
3273  PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3274  {
3275  f2c( a, aa, nx, ny );
3276  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3277  }
3278 
3279 // plimagefr() for use with pltr1
3280  void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3281  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3282  PLFLT zmin, PLFLT zmax,
3283  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3284  {
3285  PLcGrid grid1;
3286  grid1.nx = nx + 1; grid1.ny = ny + 1;
3287  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3288  f2c( a, aa, nx, ny );
3289  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3290  }
3291 
3292 // plimagefr() for use with pltr2
3293  void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3294  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3295  PLFLT zmin, PLFLT zmax,
3296  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3297  {
3298  PLcGrid2 grid2;
3299  f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3300  f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3301  grid2.nx = nx + 1; grid2.ny = ny + 1;
3302  grid2.xg = xgg; grid2.yg = ygg;
3303  f2c( a, aa, nx, ny );
3304  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3305  }
3306 
3307 
3308 
3309  void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3310  PLINT opt, PLINT position, PLFLT x, PLFLT y,
3311  PLFLT x_length, PLFLT y_length,
3312  PLINT bg_color, PLINT bb_color, PLINT bb_style,
3313  PLFLT low_cap_color, PLFLT high_cap_color,
3314  PLINT cont_color, PLFLT cont_width,
3315  PLINT n_labels, const PLINT *label_opts, const char **label,
3316  PLINT n_axes, const char ** axis_opts,
3317  const PLFLT *ticks, const PLINT *sub_ticks,
3318  const PLINT *n_values, const PLFLT *a )
3319  {
3320  PLINT nx, ny, i;
3321  nx = n_axes;
3322  ny = -1;
3323  for ( i = 0; i < nx; i++ )
3324  if ( n_values[i] > ny )
3325  ny = n_values[i];
3326  f2c( a, aa, nx, ny );
3327  c_plcolorbar( p_colorbar_width, p_colorbar_height,
3328  opt, position, x, y,
3329  x_length, y_length,
3330  bg_color, bb_color, bb_style,
3331  low_cap_color, high_cap_color,
3332  cont_color, cont_width,
3333  n_labels, label_opts, label,
3334  n_axes, axis_opts,
3335  ticks, sub_ticks,
3336  n_values, aa );
3337  }
3338 
3339 
3340 
3341  SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3342  {
3343  if (!ov.is_scalar_type())
3344  return SWIG_TypeError;
3345  if (ov.is_complex_scalar())
3346  return SWIG_TypeError;
3347  if (ov.is_double_type()||ov.is_single_type()) {
3348  double v=ov.double_value();
3349  if (v<0)
3350  return SWIG_OverflowError;
3351  if (v!=floor(v))
3352  return SWIG_TypeError;
3353  }
3354  if (ov.is_int8_type()||ov.is_int16_type()||
3355  ov.is_int32_type()) {
3356  long v=ov.long_value();
3357  if (v<0)
3358  return SWIG_OverflowError;
3359  }
3360  if (ov.is_int64_type()) {
3361  long long v=ov.int64_scalar_value().value();
3362  if (v<0)
3363  return SWIG_OverflowError;
3364  }
3365  if (val)
3366  *val = ov.ulong_value();
3367  return SWIG_OK;
3368  }
3369 
3370 
3371 SWIGINTERN int
3372 SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3373 {
3374  unsigned long v;
3375  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3376  if (SWIG_IsOK(res)) {
3377  if ((v > UINT_MAX)) {
3378  return SWIG_OverflowError;
3379  } else {
3380  if (val) *val = static_cast< unsigned int >(v);
3381  }
3382  }
3383  return res;
3384 }
3385 
3386 
3388  {
3389  return octave_value(value);
3390  }
3391 
3392 
3393 SWIGINTERNINLINE octave_value
3395 {
3397 }
3398 
3399 
3400 SWIGINTERN int
3401 SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3402 {
3403  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3404  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3405  if (SWIG_IsOK(res)) {
3406  /* special case of single char conversion when we don't need space for NUL */
3407  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3408  if (csize <= size) {
3409  if (val) {
3410  if (csize) memcpy(val, cptr, csize*sizeof(char));
3411  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3412  }
3413  if (alloc == SWIG_NEWOBJ) {
3414  delete[] cptr;
3415  res = SWIG_DelNewMask(res);
3416  }
3417  return res;
3418  }
3419  if (alloc == SWIG_NEWOBJ) delete[] cptr;
3420  }
3421  return SWIG_TypeError;
3422 }
3423 
3424 
3427 {
3428  static int init = 0;
3429  static swig_type_info* info = 0;
3430  if (!init) {
3431  info = SWIG_TypeQuery("_p_char");
3432  init = 1;
3433  }
3434  return info;
3435 }
3436 
3437 
3438 SWIGINTERNINLINE octave_value
3439 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3440 {
3441  return std::string(carray,carray+size);
3442 }
3443 
3444 
3445 SWIGINTERN size_t
3446 SWIG_strnlen(const char* s, size_t maxlen)
3447 {
3448  const char *p;
3449  for (p = s; maxlen-- && *p; p++)
3450  ;
3451  return p - s;
3452 }
3453 
3454 
3455 SWIGINTERN int
3456 SWIG_AsVal_char (octave_value obj, char *val)
3457 {
3458  int res = SWIG_AsCharArray(obj, val, 1);
3459  if (!SWIG_IsOK(res)) {
3460  long v;
3461  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3462  if (SWIG_IsOK(res)) {
3463  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3464  if (val) *val = static_cast< char >(v);
3465  } else {
3466  res = SWIG_OverflowError;
3467  }
3468  }
3469  }
3470  return res;
3471 }
3472 
3473 static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3474 Specify viewport in absolute coordinates\n\
3475 \n\
3476 DESCRIPTION:\n\
3477 \n\
3478  Alternate routine to plvpor for setting up the viewport. This routine\n\
3479  should be used only if the viewport is required to have a definite\n\
3480  size in millimeters. The routine plgspa is useful for finding out the\n\
3481  size of the current subpage.\n\
3482 \n\
3483  Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3484 \n\
3485  This function is used in example 10.\n\
3486 \n\
3487 \n\
3488 \n\
3489 SYNOPSIS:\n\
3490 \n\
3491 plsvpa(xmin, xmax, ymin, ymax)\n\
3492 \n\
3493 ARGUMENTS:\n\
3494 \n\
3495  xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3496  viewport from the left-hand edge of the subpage in millimeters.\n\
3497 \n\
3498  xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3499  viewport from the left-hand edge of the subpage in millimeters.\n\
3500 \n\
3501  ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3502  viewport from the bottom edge of the subpage in millimeters.\n\
3503 \n\
3504  ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3505  from the bottom edge of the subpage in millimeters.\n\
3506 ";
3507 static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3508 Write text relative to viewport boundaries in 3D plots\n\
3509 \n\
3510 DESCRIPTION:\n\
3511 \n\
3512  Writes text at a specified position relative to the viewport\n\
3513  boundaries. Text may be written inside or outside the viewport, but\n\
3514  is clipped at the subpage boundaries. The reference point of a string\n\
3515  lies along a line passing through the string at half the height of a\n\
3516  capital letter. The position of the reference point along this line\n\
3517  is determined by just, and the position of the reference point\n\
3518  relative to the viewport is set by disp and pos.\n\
3519 \n\
3520  Redacted form: plmtex3(side, disp, pos, just, text)\n\
3521 \n\
3522  This function is used in example 28.\n\
3523 \n\
3524 \n\
3525 \n\
3526 SYNOPSIS:\n\
3527 \n\
3528 plmtex3(side, disp, pos, just, text)\n\
3529 \n\
3530 ARGUMENTS:\n\
3531 \n\
3532  side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3533  the side of the viewport along which the text is to be written.\n\
3534  The string should contain one or more of the following characters:\n\
3535  [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3536  only label the X axis, not both the X and Y axes. x: Label the X\n\
3537  axis.\n\
3538  y: Label the Y axis.\n\
3539  z: Label the Z axis.\n\
3540  p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3541  For X it is the axis that starts at y-min. For Y it is the\n\
3542  axis that starts at x-min.\n\
3543  s: Label the secondary axis.\n\
3544  v: Draw the text perpendicular to the axis.\n\
3545 \n\
3546 \n\
3547  disp (PLFLT, input) : Position of the reference point of string,\n\
3548  measured outwards from the specified viewport edge in units of the\n\
3549  current character height. Use negative disp to write within the\n\
3550  viewport.\n\
3551 \n\
3552  pos (PLFLT, input) : Position of the reference point of string\n\
3553  along the specified edge, expressed as a fraction of the length of\n\
3554  the edge.\n\
3555 \n\
3556  just (PLFLT, input) : Specifies the position of the string relative\n\
3557  to its reference point. If just=0. , the reference point is at\n\
3558  the left and if just=1. , it is at the right of the string. Other\n\
3559  values of just give intermediate justifications.\n\
3560 \n\
3561  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3562  written out.\n\
3563 ";
3564 static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3565 Set semitransparent cmap1 RGBA colors.\n\
3566 \n\
3567 DESCRIPTION:\n\
3568 \n\
3569  Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3570  RGBA vector values. This function also sets the number of cmap1\n\
3571  colors. N.B. Continuous cmap1 colors are indexed with a\n\
3572  floating-point index in the range from 0.0-1.0 which is linearly\n\
3573  transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3574  vectors in the range from 0 to\n\
3575  ncol1-1. So in order for this continuous color model to work\n\
3576  properly, it is the responsibility of the user of plscmap1 to insure\n\
3577  that these RGBA vectors are continuous functions of their integer\n\
3578  indices.\n\
3579 \n\
3580  Redacted form: plscmap1a(r, g, b, alpha)\n\
3581 \n\
3582  This function is used in example 31.\n\
3583 \n\
3584 \n\
3585 \n\
3586 SYNOPSIS:\n\
3587 \n\
3588 plscmap1a(r, g, b, alpha, ncol1)\n\
3589 \n\
3590 ARGUMENTS:\n\
3591 \n\
3592  r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3593  8-bit integers in the range from 0-255) the degree of red in the\n\
3594  color as a continuous function of the integer index of the vector.\n\
3595 \n\
3596  g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3597  8-bit integers in the range from 0-255) the degree of green in the\n\
3598  color as a continuous function of the integer index of the vector.\n\
3599 \n\
3600  b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3601  8-bit integers in the range from 0-255) the degree of blue in the\n\
3602  color as a continuous function of the integer index of the vector.\n\
3603 \n\
3604  alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3605  values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3606  completely transparent and 1.0 corresponds to completely opaque)\n\
3607  the alpha transparency of the color as a continuous function of\n\
3608  the integer index of the vector.\n\
3609 \n\
3610  ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3611  vectors.\n\
3612 ";
3613 static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3614 Select standard viewport\n\
3615 \n\
3616 DESCRIPTION:\n\
3617 \n\
3618  Selects the largest viewport within the subpage that leaves a standard\n\
3619  margin (left-hand margin of eight character heights, and a margin\n\
3620  around the other three sides of five character heights).\n\
3621 \n\
3622  Redacted form: plvsta()\n\
3623 \n\
3624  This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3625 \n\
3626 \n\
3627 \n\
3628 SYNOPSIS:\n\
3629 \n\
3630 plvsta()\n\
3631 ";
3632 static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3633 Switch to graphics screen\n\
3634 \n\
3635 DESCRIPTION:\n\
3636 \n\
3637  Sets an interactive device to graphics mode, used in conjunction with\n\
3638  pltext to allow graphics and text to be interspersed. On a device\n\
3639  which supports separate text and graphics windows, this command causes\n\
3640  control to be switched to the graphics window. If already in graphics\n\
3641  mode, this command is ignored. It is also ignored on devices which\n\
3642  only support a single window or use a different method for shifting\n\
3643  focus. See also pltext.\n\
3644 \n\
3645  Redacted form: plgra()\n\
3646 \n\
3647  This function is used in example 1.\n\
3648 \n\
3649 \n\
3650 \n\
3651 SYNOPSIS:\n\
3652 \n\
3653 plgra()\n\
3654 ";
3655 static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3656 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3657 \n\
3658 DESCRIPTION:\n\
3659 \n\
3660  Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3661  (see the PLplot documentation) index. Overwrites the previous color\n\
3662  value for the given index and, thus, does not result in any additional\n\
3663  allocation of space for colors.\n\
3664 \n\
3665  This function is used in example 30.\n\
3666 \n\
3667 \n\
3668 \n\
3669 SYNOPSIS:\n\
3670 \n\
3671 plscol0a(icol0, r, g, b, alpha)\n\
3672 \n\
3673 ARGUMENTS:\n\
3674 \n\
3675  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3676  number of colors (which is set by default, by plscmap0n, or even\n\
3677  by plscmap0).\n\
3678 \n\
3679  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3680  degree of red in the color.\n\
3681 \n\
3682  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3683  degree of green in the color.\n\
3684 \n\
3685  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3686  degree of blue in the color.\n\
3687 \n\
3688  alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3689  (0.0-1.0).\n\
3690 ";
3691 static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3692 Set y axis parameters\n\
3693 \n\
3694 DESCRIPTION:\n\
3695 \n\
3696  Identical to plsxax, except that arguments are flags for y axis. See\n\
3697  the description of plsxax for more detail.\n\
3698 \n\
3699  Redacted form: plsyax(digmax, digits)\n\
3700 \n\
3701  This function is used in examples 1, 14, and 31.\n\
3702 \n\
3703 \n\
3704 \n\
3705 SYNOPSIS:\n\
3706 \n\
3707 plsyax(digmax, digits)\n\
3708 \n\
3709 ARGUMENTS:\n\
3710 \n\
3711  digmax (PLINT, input) : Variable to set the maximum number of\n\
3712  digits for the y axis. If nonzero, the printed label will be\n\
3713  switched to a floating-point representation when the number of\n\
3714  digits exceeds digmax.\n\
3715 \n\
3716  digits (PLINT, input) : Field digits value. Currently, changing\n\
3717  its value here has no effect since it is set only by plbox or\n\
3718  plbox3. However, the user may obtain its value after a call to\n\
3719  either of these functions by calling plgyax.\n\
3720 ";
3721 static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3722 Returns 8-bit RGB values for given color index from cmap0\n\
3723 \n\
3724 DESCRIPTION:\n\
3725 \n\
3726  Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3727  PLplot documentation). Values are negative if an invalid color id is\n\
3728  given.\n\
3729 \n\
3730  Redacted form: plgcol0(icol0, r, g, b)\n\
3731 \n\
3732  This function is used in example 2.\n\
3733 \n\
3734 \n\
3735 \n\
3736 SYNOPSIS:\n\
3737 \n\
3738 plgcol0(icol0, r, g, b)\n\
3739 \n\
3740 ARGUMENTS:\n\
3741 \n\
3742  icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3743 \n\
3744  r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3745  value.\n\
3746 \n\
3747  g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3748  value.\n\
3749 \n\
3750  b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3751  value.\n\
3752 ";
3753 static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3754 Set seed for internal random number generator.\n\
3755 \n\
3756 DESCRIPTION:\n\
3757 \n\
3758  Set the seed for the internal random number generator. See plrandd for\n\
3759  further details.\n\
3760 \n\
3761  Redacted form: plseed(seed)\n\
3762 \n\
3763  This function is used in example 21.\n\
3764 \n\
3765 \n\
3766 \n\
3767 SYNOPSIS:\n\
3768 \n\
3769 plseed(seed)\n\
3770 \n\
3771 ARGUMENTS:\n\
3772 \n\
3773  seed (unsigned int, input) : Seed for random number generator.\n\
3774 ";
3775 static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
3776 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3777 \n\
3778 DESCRIPTION:\n\
3779 \n\
3780  When the implementation is completed this variant of plot3dc (see that\n\
3781  function\'s documentation for more details) should be suitable for the\n\
3782  case where the area of the x, y coordinate grid where z is defined can\n\
3783  be non-rectangular. The implementation is incomplete so the last 4\n\
3784  parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3785  indexymax; are currently ignored and the functionality is otherwise\n\
3786  identical to that of plot3dc.\n\
3787 \n\
3788  Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3789  indexymin, indexymax)\n\
3790 \n\
3791 \n\
3792  This function is not used in any example.\n\
3793 \n\
3794 \n\
3795 \n\
3796 SYNOPSIS:\n\
3797 \n\
3798 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3799 \n\
3800 ARGUMENTS:\n\
3801 \n\
3802  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3803  which the function is evaluated.\n\
3804 \n\
3805  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3806  which the function is evaluated.\n\
3807 \n\
3808  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3809  plot. Should have dimensions of\n\
3810  nx by\n\
3811  ny.\n\
3812 \n\
3813  nx (PLINT, input) : Number of x values at which the function is\n\
3814  evaluated.\n\
3815 \n\
3816  ny (PLINT, input) : Number of y values at which the function is\n\
3817  evaluated.\n\
3818 \n\
3819  opt (PLINT, input) : Determines the way in which the surface is\n\
3820  represented. To specify more than one option just add the options,\n\
3821  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3822  showing z as a function of x for each value of y[j] .\n\
3823  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3824  for each value of x[i] .\n\
3825  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3826  at which function is defined.\n\
3827  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3828  the z value being plotted. The color is used from the current\n\
3829  cmap1.\n\
3830  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3831  using parameters\n\
3832  nlevel and\n\
3833  clevel.\n\
3834  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3835  the borders of the plotted function.\n\
3836 \n\
3837 \n\
3838  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3839  levels.\n\
3840 \n\
3841  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3842 \n\
3843  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3844  corresponds to the first x index where z is defined.\n\
3845 \n\
3846  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3847  which corresponds (by convention) to one more than the last x\n\
3848  index value where z is defined.\n\
3849 \n\
3850  indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3851  values which all must be ≥ 0. These values are the first y index\n\
3852  where z is defined for a particular x index in the range from\n\
3853  indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3854  indexxmax.\n\
3855 \n\
3856  indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3857  values which all must be ≤ ny. These values correspond (by\n\
3858  convention) to one more than the last y index where z is defined\n\
3859  for a particular x index in the range from indexxmin to indexxmax\n\
3860  - 1. The dimension of indexymax is indexxmax.\n\
3861 ";
3862 static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3863 Get output file name\n\
3864 \n\
3865 DESCRIPTION:\n\
3866 \n\
3867  Gets the current output file name, if applicable.\n\
3868 \n\
3869  Redacted form: plgfnam(fnam)\n\
3870 \n\
3871  This function is used in example 31.\n\
3872 \n\
3873 \n\
3874 \n\
3875 SYNOPSIS:\n\
3876 \n\
3877 plgfnam(fnam)\n\
3878 \n\
3879 ARGUMENTS:\n\
3880 \n\
3881  fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3882  (with preallocated length of 80 characters or more) containing the\n\
3883  file name.\n\
3884 ";
3885 static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3886 Specify window\n\
3887 \n\
3888 DESCRIPTION:\n\
3889 \n\
3890  Specify the window, i.e., the world coordinates of the edges of the\n\
3891  viewport.\n\
3892 \n\
3893  Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3894 \n\
3895  This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3896  29, and 31.\n\
3897 \n\
3898 \n\
3899 \n\
3900 SYNOPSIS:\n\
3901 \n\
3902 plwind(xmin, xmax, ymin, ymax)\n\
3903 \n\
3904 ARGUMENTS:\n\
3905 \n\
3906  xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3907  of the viewport.\n\
3908 \n\
3909  xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3910  of the viewport.\n\
3911 \n\
3912  ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3913  the viewport.\n\
3914 \n\
3915  ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3916  viewport.\n\
3917 ";
3918 static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
3919 Set cmap1 colors using a piece-wise linear relationship\n\
3920 \n\
3921 DESCRIPTION:\n\
3922 \n\
3923  Set cmap1 colors using a piece-wise linear relationship between the\n\
3924  cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
3925  (see the PLplot documentation). May be called at any time.\n\
3926 \n\
3927  The idea here is to specify a number of control points that define the\n\
3928  mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
3929  these points, linear interpolation is used which gives a smooth\n\
3930  variation of color with intensity index. Any number of control points\n\
3931  may be specified, located at arbitrary positions, although typically 2\n\
3932  - 4 are enough. Another way of stating this is that we are traversing\n\
3933  a given number of lines through HLS or RGB space as we move through\n\
3934  cmap1 intensity indices. The control points at the minimum and\n\
3935  maximum position (0 and 1) must always be specified. By adding more\n\
3936  control points you can get more variation. One good technique for\n\
3937  plotting functions that vary about some expected average is to use an\n\
3938  additional 2 control points in the center (position ~= 0.5) that are\n\
3939  the same lightness as the background (typically white for paper\n\
3940  output, black for crt), and same hue as the boundary control points.\n\
3941  This allows the highs and lows to be very easily distinguished.\n\
3942 \n\
3943  Each control point must specify the cmap1 intensity index and the\n\
3944  associated three coordinates in HLS or RGB space. The first point\n\
3945  must correspond to position = 0, and the last to position = 1.\n\
3946 \n\
3947  If RGB colors are provided then the interpolation takes place in RGB\n\
3948  space and is trivial. However if HLS colors are provided then, because\n\
3949  of the circular nature of the color wheel for the hue coordinate, the\n\
3950  interpolation could be performed in either direction around the color\n\
3951  wheel. The default behaviour is for the hue to be linearly\n\
3952  interpolated ignoring this circular property of hue. So for example,\n\
3953  the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
3954  green and cyan. If instead you wish to interpolate the other way\n\
3955  around the color wheel you have two options. You may provide hues\n\
3956  outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
3957  for red the interpolation will proceed via magenta. Alternatively you\n\
3958  can utilise the alt_hue_path variable to reverse the direction of\n\
3959  interpolation if you need to provide hues within the [0-360) range.\n\
3960 \n\
3961  Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3962  240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3963  -120]falsegreen-yellow-red-magenta-blue[240\n\
3964  480]falseblue-magenta-red-yellow-green[120\n\
3965  240]truegreen-yellow-red-magenta-blue[240\n\
3966  120]trueblue-magenta-red-yellow-green\n\
3967 \n\
3968  Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3969  1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3970  1]magnitudeHLSsaturation[0, 1]magnitude\n\
3971 \n\
3972  Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
3973  alt_hue_path)\n\
3974 \n\
3975  This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
3976 \n\
3977 \n\
3978 \n\
3979 SYNOPSIS:\n\
3980 \n\
3981 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
3982 \n\
3983 ARGUMENTS:\n\
3984 \n\
3985  itype (PLBOOL, input) : true: RGB, false: HLS.\n\
3986 \n\
3987  npts (PLINT, input) : number of control points\n\
3988 \n\
3989  intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
3990  intensity index (0.0-1.0) in ascending order for each control\n\
3991  point.\n\
3992 \n\
3993  coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
3994  coordinate (H or R) for each control point.\n\
3995 \n\
3996  coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
3997  coordinate (L or G) for each control point.\n\
3998 \n\
3999  coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
4000  coordinate (S or B) for each control point.\n\
4001 \n\
4002  alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
4003  npts - 1 elements), each containing either true to use the reversed\n\
4004  HLS interpolation or false to use the regular HLS interpolation.\n\
4005  (alt_hue_path[i] refers to the interpolation interval between the\n\
4006  i and i + 1 control points). This parameter is not used for RGB\n\
4007  colors (\n\
4008  itype = true).\n\
4009 ";
4010 static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
4011 Set the pause (on end-of-page) status\n\
4012 \n\
4013 DESCRIPTION:\n\
4014 \n\
4015  Set the pause (on end-of-page) status.\n\
4016 \n\
4017  Redacted form: plspause(pause)\n\
4018 \n\
4019  This function is in examples 14,20.\n\
4020 \n\
4021 \n\
4022 \n\
4023 SYNOPSIS:\n\
4024 \n\
4025 plspause(pause)\n\
4026 \n\
4027 ARGUMENTS:\n\
4028 \n\
4029  pause (PLBOOL, input) : If pause is true there will be a pause on\n\
4030  end-of-page for those drivers which support this. Otherwise there\n\
4031  is no pause.\n\
4032 ";
4033 static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
4034 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
4035 \n\
4036 DESCRIPTION:\n\
4037 \n\
4038  Routine for creating a discrete plot legend with a plotted filled box,\n\
4039  line, and/or line of symbols for each annotated legend entry. (See\n\
4040  plcolorbar for similar functionality for creating continuous color\n\
4041  bars.) The arguments of pllegend provide control over the location\n\
4042  and size of the legend as well as the location and characteristics of\n\
4043  the elements (most of which are optional) within that legend. The\n\
4044  resulting legend is clipped at the boundaries of the current subpage.\n\
4045  (N.B. the adopted coordinate system used for some of the parameters is\n\
4046  defined in the documentation of the position parameter.)\n\
4047 \n\
4048  Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
4049  position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
4050  ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
4051  test_justification, text_colors, text, box_colors, box_patterns,\n\
4052  box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
4053  symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
4054 \n\
4055  This function is used in examples 4, 26, and 33.\n\
4056 \n\
4057 \n\
4058 \n\
4059 SYNOPSIS:\n\
4060 \n\
4061 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\
4062 \n\
4063 ARGUMENTS:\n\
4064 \n\
4065  p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4066  legend width in adopted coordinates. This quantity is calculated\n\
4067  from plot_width, text_offset, ncolumn (possibly modified inside\n\
4068  the routine depending on nlegend and nrow), and the length\n\
4069  (calculated internally) of the longest text string.\n\
4070 \n\
4071  p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4072  legend height in adopted coordinates. This quantity is calculated\n\
4073  from text_scale, text_spacing, and nrow (possibly modified inside\n\
4074  the routine depending on nlegend and nrow).\n\
4075 \n\
4076  opt (PLINT, input) : opt contains bits controlling the overall\n\
4077  legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
4078  on the left of the legend and the plotted area on the right.\n\
4079  Otherwise, put the text area on the right of the legend and the\n\
4080  plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
4081  plot a (semitransparent) background for the legend. If the\n\
4082  PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
4083  legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
4084  possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
4085  plot the resulting array of legend entries in row-major order.\n\
4086  Otherwise, plot the legend entries in column-major order.\n\
4087 \n\
4088  position (PLINT, input) : position contains bits which control the\n\
4089  overall position of the legend and the definition of the adopted\n\
4090  coordinates used for positions just like what is done for the\n\
4091  position argument for plcolorbar. However, note that the defaults\n\
4092  for the position bits (see below) are different than the\n\
4093  plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
4094  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
4095  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
4096  the 16 possible standard positions (the 4 corners and centers of\n\
4097  the 4 sides for both the inside and outside cases) of the legend\n\
4098  relative to the adopted coordinate system. The corner positions\n\
4099  are specified by the appropriate combination of two of the\n\
4100  PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
4101  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
4102  value of one of those bits. The adopted coordinates are\n\
4103  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
4104  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
4105  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
4106  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
4107  then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
4108  If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
4109  use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
4110  PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
4111 \n\
4112  x (PLFLT, input) : X offset of the legend position in adopted\n\
4113  coordinates from the specified standard position of the legend.\n\
4114  For positive x, the direction of motion away from the standard\n\
4115  position is inward/outward from the standard corner positions or\n\
4116  standard left or right positions if the\n\
4117  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
4118  For the standard top or bottom positions, the direction of motion\n\
4119  is toward positive X.\n\
4120 \n\
4121  y (PLFLT, input) : Y offset of the legend position in adopted\n\
4122  coordinates from the specified standard position of the legend.\n\
4123  For positive y, the direction of motion away from the standard\n\
4124  position is inward/outward from the standard corner positions or\n\
4125  standard top or bottom positions if the\n\
4126  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
4127  the standard left or right positions, the direction of motion is\n\
4128  toward positive Y.\n\
4129 \n\
4130  plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
4131  of the plot area (where the colored boxes, lines, and/or lines of\n\
4132  symbols are drawn) of the legend.\n\
4133 \n\
4134  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
4135  legend (PL_LEGEND_BACKGROUND).\n\
4136 \n\
4137  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
4138  for the legend (PL_LEGEND_BOUNDING_BOX).\n\
4139 \n\
4140  bb_style (PLINT, input) : The pllsty style number for the\n\
4141  bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
4142 \n\
4143  nrow (PLINT, input) : The number of rows in the matrix used to\n\
4144  render the\n\
4145  nlegend legend entries. For internal transformations of\n\
4146  nrow, see further remarks under\n\
4147  nlegend.\n\
4148 \n\
4149  ncolumn (PLINT, input) : The number of columns in the matrix used\n\
4150  to render the\n\
4151  nlegend legend entries. For internal transformations of\n\
4152  ncolumn, see further remarks under\n\
4153  nlegend.\n\
4154 \n\
4155  nlegend (PLINT, input) : Number of legend entries. The above\n\
4156  nrow and\n\
4157  ncolumn values are transformed internally to be consistent with\n\
4158  nlegend. If either\n\
4159  nrow or\n\
4160  ncolumn is non-positive it is replaced by 1. If the resulting product\n\
4161  of\n\
4162  nrow and\n\
4163  ncolumn is less than\n\
4164  nlegend, the smaller of the two (or\n\
4165  nrow, if\n\
4166  nrow ==\n\
4167  ncolumn) is increased so the product is >=\n\
4168  nlegend. Thus, for example, the common\n\
4169  nrow = 0,\n\
4170  ncolumn = 0 case is transformed internally to\n\
4171  nrow =\n\
4172  nlegend,\n\
4173  ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
4174  column.\n\
4175 \n\
4176  opt_array (PLINT_VECTOR, input) : A vector of\n\
4177  nlegend values of options to control each individual plotted area\n\
4178  corresponding to a legend entry. If the\n\
4179  PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
4180  area. If the\n\
4181  PL_LEGEND_COLOR_BOX,\n\
4182  PL_LEGEND_LINE, and/or\n\
4183  PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
4184  entry is plotted with a colored box; a line; and/or a line of\n\
4185  symbols.\n\
4186 \n\
4187  text_offset (PLFLT, input) : Offset of the text area from the plot\n\
4188  area in units of character width.\n\
4189 \n\
4190  text_scale (PLFLT, input) : Character height scale for text\n\
4191  annotations.\n\
4192 \n\
4193  text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
4194  character height from one legend entry to the next.\n\
4195 \n\
4196  text_justification (PLFLT, input) : Justification parameter used\n\
4197  for text justification. The most common values of\n\
4198  text_justification are 0., 0.5, or 1. corresponding to a text that\n\
4199  is left justified, centred, or right justified within the text\n\
4200  area, but other values are allowed as well.\n\
4201 \n\
4202  text_colors (PLINT_VECTOR, input) : A vector containing\n\
4203  nlegend cmap0 text colors.\n\
4204 \n\
4205  text (PLCHAR_MATRIX, input) : A vector of\n\
4206  nlegend UTF-8 character strings containing the legend annotations.\n\
4207 \n\
4208  box_colors (PLINT_VECTOR, input) : A vector containing\n\
4209  nlegend cmap0 colors for the discrete colored boxes (\n\
4210  PL_LEGEND_COLOR_BOX).\n\
4211 \n\
4212  box_patterns (PLINT_VECTOR, input) : A vector containing\n\
4213  nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
4214  PL_LEGEND_COLOR_BOX).\n\
4215 \n\
4216  box_scales (PLFLT_VECTOR, input) : A vector containing\n\
4217  nlegend scales (units of fraction of character height) for the height\n\
4218  of the discrete colored boxes (\n\
4219  PL_LEGEND_COLOR_BOX).\n\
4220 \n\
4221  box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4222  nlegend line widths for the patterns specified by box_patterns (\n\
4223  PL_LEGEND_COLOR_BOX).\n\
4224 \n\
4225  line_colors (PLINT_VECTOR, input) : A vector containing\n\
4226  nlegend cmap0 line colors (\n\
4227  PL_LEGEND_LINE).\n\
4228 \n\
4229  line_styles (PLINT_VECTOR, input) : A vector containing\n\
4230  nlegend line styles (plsty indices) (\n\
4231  PL_LEGEND_LINE).\n\
4232 \n\
4233  line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4234  nlegend line widths (\n\
4235  PL_LEGEND_LINE).\n\
4236 \n\
4237  symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
4238  nlegend cmap0 symbol colors (\n\
4239  PL_LEGEND_SYMBOL).\n\
4240 \n\
4241  symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
4242  nlegend scale values for the symbol height (\n\
4243  PL_LEGEND_SYMBOL).\n\
4244 \n\
4245  symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
4246  nlegend numbers of symbols to be drawn across the width of the plotted\n\
4247  area (\n\
4248  PL_LEGEND_SYMBOL).\n\
4249 \n\
4250  symbols (PLCHAR_MATRIX, input) : A vector of\n\
4251  nlegend UTF-8 character strings containing the legend symbols. (\n\
4252  PL_LEGEND_SYMBOL).\n\
4253 ";
4254 static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
4255 Set number of colors in cmap1\n\
4256 \n\
4257 DESCRIPTION:\n\
4258 \n\
4259  Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
4260  values if this is the first allocation (see the PLplot documentation).\n\
4261 \n\
4262  Redacted form: plscmap1n(ncol1)\n\
4263 \n\
4264  This function is used in examples 8, 11, 20, and 21.\n\
4265 \n\
4266 \n\
4267 \n\
4268 SYNOPSIS:\n\
4269 \n\
4270 plscmap1n(ncol1)\n\
4271 \n\
4272 ARGUMENTS:\n\
4273 \n\
4274  ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
4275  the cmap1 palette. If this number is zero or less, then the value\n\
4276  from the previous call to plscmap1n is used and if there is no\n\
4277  previous call, then a default value is used.\n\
4278 ";
4279 static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
4280 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
4281 \n\
4282 DESCRIPTION:\n\
4283 \n\
4284  Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
4285  (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
4286  Values are negative if an invalid color id is given.\n\
4287 \n\
4288  Redacted form: plgcola(r, g, b)\n\
4289 \n\
4290  This function is used in example 30.\n\
4291 \n\
4292 \n\
4293 \n\
4294 SYNOPSIS:\n\
4295 \n\
4296 plgcol0a(icol0, r, g, b, alpha)\n\
4297 \n\
4298 ARGUMENTS:\n\
4299 \n\
4300  icol0 (PLINT, input) : Index of desired cmap0 color.\n\
4301 \n\
4302  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
4303  in the range from 0 to 255.\n\
4304 \n\
4305  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
4306  in the range from 0 to 255.\n\
4307 \n\
4308  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
4309  in the range from 0 to 255.\n\
4310 \n\
4311  alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
4312  transparency in the range from (0.0-1.0).\n\
4313 ";
4314 static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
4315 Replays contents of plot buffer to current device/file\n\
4316 \n\
4317 DESCRIPTION:\n\
4318 \n\
4319  Replays contents of plot buffer to current device/file.\n\
4320 \n\
4321  Redacted form: plreplot()\n\
4322 \n\
4323  This function is used in example 1,20.\n\
4324 \n\
4325 \n\
4326 \n\
4327 SYNOPSIS:\n\
4328 \n\
4329 plreplot()\n\
4330 ";
4331 static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
4332 Simple routine to write labels\n\
4333 \n\
4334 DESCRIPTION:\n\
4335 \n\
4336  Routine for writing simple labels. Use plmtex for more complex labels.\n\
4337 \n\
4338  Redacted form: pllab(xlabel, ylabel, tlabel)\n\
4339 \n\
4340  This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
4341 \n\
4342 \n\
4343 \n\
4344 SYNOPSIS:\n\
4345 \n\
4346 pllab(xlabel, ylabel, tlabel)\n\
4347 \n\
4348 ARGUMENTS:\n\
4349 \n\
4350  xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4351  the label for the x axis.\n\
4352 \n\
4353  ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4354  the label for the y axis.\n\
4355 \n\
4356  tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4357  the title of the plot.\n\
4358 ";
4359 static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
4360 Set parameters that define current device-space window\n\
4361 \n\
4362 DESCRIPTION:\n\
4363 \n\
4364  Set relative margin width, aspect ratio, and relative justification\n\
4365  that define current device-space window. If you want to just use the\n\
4366  previous value for any of these, just pass in the magic value\n\
4367  PL_NOTSET. It is unlikely that one should ever need to change the\n\
4368  aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4369  called the default values of mar, jx, and jy are all 0. aspect is set\n\
4370  to a device-specific value.\n\
4371 \n\
4372  Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4373 \n\
4374  This function is used in example 31.\n\
4375 \n\
4376 \n\
4377 \n\
4378 SYNOPSIS:\n\
4379 \n\
4380 plsdidev(mar, aspect, jx, jy)\n\
4381 \n\
4382 ARGUMENTS:\n\
4383 \n\
4384  mar (PLFLT, input) : Relative margin width.\n\
4385 \n\
4386  aspect (PLFLT, input) : Aspect ratio.\n\
4387 \n\
4388  jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4389  the range -0.5 to 0.5.\n\
4390 \n\
4391  jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4392  the range -0.5 to 0.5.\n\
4393 ";
4394 static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
4395 Begin a new page\n\
4396 \n\
4397 DESCRIPTION:\n\
4398 \n\
4399  Begins a new page. For a file driver, the output file is opened if\n\
4400  necessary. Advancing the page via pleop and plbop is useful when a\n\
4401  page break is desired at a particular point when plotting to subpages.\n\
4402  Another use for pleop and plbop is when plotting pages to different\n\
4403  files, since you can manually set the file name by calling plsfnam\n\
4404  after the call to pleop. (In fact some drivers may only support a\n\
4405  single page per file, making this a necessity.) One way to handle\n\
4406  this case automatically is to page advance via pladv, but enable\n\
4407  familying (see plsfam) with a small limit on the file size so that a\n\
4408  new family member file will be created on each page break.\n\
4409 \n\
4410  Redacted form: plbop()\n\
4411 \n\
4412  This function is used in examples 2 and 20.\n\
4413 \n\
4414 \n\
4415 \n\
4416 SYNOPSIS:\n\
4417 \n\
4418 plbop()\n\
4419 ";
4420 static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
4421 Set cmap0 colors by 8-bit RGB values\n\
4422 \n\
4423 DESCRIPTION:\n\
4424 \n\
4425  Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4426  documentation). This sets the entire color map -- only as many colors\n\
4427  as specified will be allocated.\n\
4428 \n\
4429  Redacted form: plscmap0(r, g, b)\n\
4430 \n\
4431  This function is used in examples 2 and 24.\n\
4432 \n\
4433 \n\
4434 \n\
4435 SYNOPSIS:\n\
4436 \n\
4437 plscmap0(r, g, b, ncol0)\n\
4438 \n\
4439 ARGUMENTS:\n\
4440 \n\
4441  r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4442  integers (0-255) representing the degree of red in the color.\n\
4443 \n\
4444  g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4445  integers (0-255) representing the degree of green in the color.\n\
4446 \n\
4447  b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4448  integers (0-255) representing the degree of blue in the color.\n\
4449 \n\
4450  ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4451 ";
4452 static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
4453 Set the number of subpages in x and y\n\
4454 \n\
4455 DESCRIPTION:\n\
4456 \n\
4457  Set the number of subpages in x and y.\n\
4458 \n\
4459  Redacted form: plssub(nx, ny)\n\
4460 \n\
4461  This function is examples 1,2,14,21,25,27.\n\
4462 \n\
4463 \n\
4464 \n\
4465 SYNOPSIS:\n\
4466 \n\
4467 plssub(nx, ny)\n\
4468 \n\
4469 ARGUMENTS:\n\
4470 \n\
4471  nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4472  of window columns).\n\
4473 \n\
4474  ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4475  of window rows).\n\
4476 ";
4477 static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
4478 Set a global coordinate transform function\n\
4479 \n\
4480 DESCRIPTION:\n\
4481 \n\
4482  This function can be used to define a coordinate transformation which\n\
4483  affects all elements drawn within the current plot window. The\n\
4484  coordinate_transform callback function is similar to that provided for\n\
4485  the plmap and plmeridians functions. The coordinate_transform_data\n\
4486  parameter may be used to pass extra data to coordinate_transform.\n\
4487 \n\
4488  Redacted form: General: plstransform(coordinate_transform,\n\
4489  coordinate_transform_data)\n\
4490 \n\
4491 \n\
4492  This function is used in examples 19 and 22.\n\
4493 \n\
4494 \n\
4495 \n\
4496 SYNOPSIS:\n\
4497 \n\
4498 plstransform(coordinate_transform, coordinate_transform_data)\n\
4499 \n\
4500 ARGUMENTS:\n\
4501 \n\
4502  coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4503  function that defines the transformation from the input (x, y)\n\
4504  world coordinates to new PLplot world coordinates. If\n\
4505  coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4506  case), then no transform is applied.\n\
4507 \n\
4508  coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4509  for\n\
4510  coordinate_transform.\n\
4511 ";
4512 static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
4513 Set opaque RGB cmap1 colors values\n\
4514 \n\
4515 DESCRIPTION:\n\
4516 \n\
4517  Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4518  vector values. This function also sets the number of cmap1 colors.\n\
4519  N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4520  in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4521  plcol1) to an integer index of these RGB vectors in the range from 0\n\
4522  to\n\
4523  ncol1-1. So in order for this continuous color model to work\n\
4524  properly, it is the responsibility of the user of plscmap1 to insure\n\
4525  that these RGB vectors are continuous functions of their integer\n\
4526  indices.\n\
4527 \n\
4528  Redacted form: plscmap1(r, g, b)\n\
4529 \n\
4530  This function is used in example 31.\n\
4531 \n\
4532 \n\
4533 \n\
4534 SYNOPSIS:\n\
4535 \n\
4536 plscmap1(r, g, b, ncol1)\n\
4537 \n\
4538 ARGUMENTS:\n\
4539 \n\
4540  r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4541  8-bit integers in the range from 0-255) the degree of red in the\n\
4542  color as a continuous function of the integer index of the vector.\n\
4543 \n\
4544  g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4545  8-bit integers in the range from 0-255) the degree of green in the\n\
4546  color as a continuous function of the integer index of the vector.\n\
4547 \n\
4548  b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4549  8-bit integers in the range from 0-255) the degree of blue in the\n\
4550  color as a continuous function of the integer index of the vector.\n\
4551 \n\
4552  ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4553 ";
4554 static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
4555 Configure the transformation between continuous and broken-down time for the current stream\n\
4556 \n\
4557 DESCRIPTION:\n\
4558 \n\
4559  Configure the transformation between continuous and broken-down time\n\
4560  for the current stream. This transformation is used by both plbtime\n\
4561  and plctime.\n\
4562 \n\
4563  Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4564  ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4565 \n\
4566 \n\
4567  This function is used in example 29.\n\
4568 \n\
4569 \n\
4570 \n\
4571 SYNOPSIS:\n\
4572 \n\
4573 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4574 \n\
4575 ARGUMENTS:\n\
4576 \n\
4577  scale (PLFLT, input) : The number of days per continuous time unit.\n\
4578  As a special case, if\n\
4579  scale is 0., then all other arguments are ignored, and the result (the\n\
4580  default used by PLplot) is the equivalent of a call to\n\
4581  plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4582  That is, for this special case broken-down time is calculated with\n\
4583  the proleptic Gregorian calendar with no leap seconds inserted,\n\
4584  and the continuous time is defined as the number of seconds since\n\
4585  the Unix epoch of 1970-01-01T00:00:00Z.\n\
4586 \n\
4587  offset1 (PLFLT, input) : If\n\
4588  ifbtime_offset is true, the parameters\n\
4589  offset1 and\n\
4590  offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4591  (with units in days) specify the epoch of the continuous time\n\
4592  relative to the MJD epoch corresponding to the Gregorian calendar\n\
4593  date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4594  are used to specify the origin to allow users (by specifying\n\
4595  offset1 as an integer that can be exactly represented by a\n\
4596  floating-point variable and specifying\n\
4597  offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4598  the numerical errors of the continuous time representation.\n\
4599 \n\
4600  offset2 (PLFLT, input) : See documentation of\n\
4601  offset1.\n\
4602 \n\
4603  ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4604  transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4605  calendar is used for broken-down time rather than the proleptic\n\
4606  Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4607  have been historically used to define UTC are inserted into the\n\
4608  broken-down time. Other possibilities for additional control bits\n\
4609  for ccontrol exist such as making the historical time corrections\n\
4610  in the broken-down time corresponding to ET (ephemeris time) or\n\
4611  making the (slightly non-constant) corrections from international\n\
4612  atomic time (TAI) to what astronomers define as terrestrial time\n\
4613  (TT). But those additional possibilities have not been\n\
4614  implemented yet in the qsastime library (one of the PLplot utility\n\
4615  libraries).\n\
4616 \n\
4617  ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4618  epoch of the continuous time scale is specified by the user. If\n\
4619  ifbtime_offset is false, then\n\
4620  offset1 and\n\
4621  offset2 are used to specify the epoch, and the following broken-down\n\
4622  time parameters are completely ignored. If\n\
4623  ifbtime_offset is true, then\n\
4624  offset1 and\n\
4625  offset2 are completely ignored, and the following broken-down time\n\
4626  parameters are used to specify the epoch.\n\
4627 \n\
4628  year (PLINT, input) : Year of epoch.\n\
4629 \n\
4630  month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4631  11 (December).\n\
4632 \n\
4633  day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4634 \n\
4635  hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4636 \n\
4637  min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4638 \n\
4639  sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4640 ";
4641 static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
4642 Set length of minor ticks\n\
4643 \n\
4644 DESCRIPTION:\n\
4645 \n\
4646  This sets up the length of the minor ticks and the length of the\n\
4647  terminals on error bars. The actual length is the product of the\n\
4648  default length and a scaling factor as for character height.\n\
4649 \n\
4650  Redacted form: plsmin(def, scale)\n\
4651 \n\
4652  This function is used in example 29.\n\
4653 \n\
4654 \n\
4655 \n\
4656 SYNOPSIS:\n\
4657 \n\
4658 plsmin(def, scale)\n\
4659 \n\
4660 ARGUMENTS:\n\
4661 \n\
4662  def (PLFLT, input) : The default length of a minor tick in\n\
4663  millimeters, should be set to zero if the default length is to\n\
4664  remain unchanged.\n\
4665 \n\
4666  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4667  actual tick length.\n\
4668 ";
4669 static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
4670 Set character size\n\
4671 \n\
4672 DESCRIPTION:\n\
4673 \n\
4674  This sets up the size of all subsequent characters drawn. The actual\n\
4675  height of a character is the product of the default character size and\n\
4676  a scaling factor.\n\
4677 \n\
4678  Redacted form: plschr(def, scale)\n\
4679 \n\
4680  This function is used in examples 2, 13, 23, and 24.\n\
4681 \n\
4682 \n\
4683 \n\
4684 SYNOPSIS:\n\
4685 \n\
4686 plschr(def, scale)\n\
4687 \n\
4688 ARGUMENTS:\n\
4689 \n\
4690  def (PLFLT, input) : The default height of a character in\n\
4691  millimeters, should be set to zero if the default height is to\n\
4692  remain unchanged. For rasterized drivers the dx and dy values\n\
4693  specified in plspage are used to convert from mm to pixels (note\n\
4694  the different unit systems used). This dpi aware scaling is not\n\
4695  implemented for all drivers yet.\n\
4696 \n\
4697  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4698  actual character height.\n\
4699 ";
4700 static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4701 Initialize PLplot\n\
4702 \n\
4703 DESCRIPTION:\n\
4704 \n\
4705  Initializing the plotting package. The program prompts for the device\n\
4706  keyword or number of the desired output device. Hitting a RETURN in\n\
4707  response to the prompt is the same as selecting the first device.\n\
4708  plinit will issue no prompt if either the device was specified\n\
4709  previously (via command line flag, the plsetopt function, or the\n\
4710  plsdev function), or if only one device is enabled when PLplot is\n\
4711  installed. If subpages have been specified, the output device is\n\
4712  divided into nx by ny subpages, each of which may be used\n\
4713  independently. If plinit is called again during a program, the\n\
4714  previously opened file will be closed. The subroutine pladv is used\n\
4715  to advance from one subpage to the next.\n\
4716 \n\
4717  Redacted form: plinit()\n\
4718 \n\
4719  This function is used in all of the examples.\n\
4720 \n\
4721 \n\
4722 \n\
4723 SYNOPSIS:\n\
4724 \n\
4725 plinit()\n\
4726 ";
4727 static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4728 Draw a box with axes, etc\n\
4729 \n\
4730 DESCRIPTION:\n\
4731 \n\
4732  Draws a box around the currently defined viewport, and labels it with\n\
4733  world coordinate values appropriate to the window. Thus plbox should\n\
4734  only be called after defining both viewport and window. The ascii\n\
4735  character strings xopt and yopt specify how the box should be drawn as\n\
4736  described below. If ticks and/or subticks are to be drawn for a\n\
4737  particular axis, the tick intervals and number of subintervals may be\n\
4738  specified explicitly, or they may be defaulted by setting the\n\
4739  appropriate arguments to zero.\n\
4740 \n\
4741  Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4742 \n\
4743 \n\
4744  This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4745  and 29.\n\
4746 \n\
4747 \n\
4748 \n\
4749 SYNOPSIS:\n\
4750 \n\
4751 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4752 \n\
4753 ARGUMENTS:\n\
4754 \n\
4755  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4756  options for the x axis. The string can include any combination of\n\
4757  the following letters (upper or lower case) in any order: a: Draws\n\
4758  axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4759  (x=0).\n\
4760  b: Draws bottom (X) or left (Y) edge of frame.\n\
4761  c: Draws top (X) or right (Y) edge of frame.\n\
4762  d: Plot labels as date / time. Values are assumed to be\n\
4763  seconds since the epoch (as used by gmtime).\n\
4764  f: Always use fixed point numeric labels.\n\
4765  g: Draws a grid at the major tick interval.\n\
4766  h: Draws a grid at the minor tick interval.\n\
4767  i: Inverts tick marks, so they are drawn outwards, rather than\n\
4768  inwards.\n\
4769  l: Labels axis logarithmically. This only affects the labels,\n\
4770  not the data, and so it is necessary to compute the logarithms\n\
4771  of data points before passing them to any of the drawing\n\
4772  routines.\n\
4773  m: Writes numeric labels at major tick intervals in the\n\
4774  unconventional location (above box for X, right of box for Y).\n\
4775  n: Writes numeric labels at major tick intervals in the\n\
4776  conventional location (below box for X, left of box for Y).\n\
4777  o: Use custom labelling function to generate axis label text.\n\
4778  The custom labelling function can be defined with the\n\
4779  plslabelfunc command.\n\
4780  s: Enables subticks between major ticks, only valid if t is\n\
4781  also specified.\n\
4782  t: Draws major ticks.\n\
4783  u: Exactly like \"b\" except don\'t draw edge line.\n\
4784  w: Exactly like \"c\" except don\'t draw edge line.\n\
4785  x: Exactly like \"t\" (including the side effect of the\n\
4786  numerical labels for the major ticks) except exclude drawing\n\
4787  the major and minor tick marks.\n\
4788 \n\
4789 \n\
4790  xtick (PLFLT, input) : World coordinate interval between major\n\
4791  ticks on the x axis. If it is set to zero, PLplot automatically\n\
4792  generates a suitable tick interval.\n\
4793 \n\
4794  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4795  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4796  generates a suitable minor tick interval.\n\
4797 \n\
4798  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4799  options for the y axis. The string can include any combination of\n\
4800  the letters defined above for xopt, and in addition may contain:\n\
4801  v: Write numeric labels for the y axis parallel to the base of the\n\
4802  graph, rather than parallel to the axis.\n\
4803 \n\
4804 \n\
4805  ytick (PLFLT, input) : World coordinate interval between major\n\
4806  ticks on the y axis. If it is set to zero, PLplot automatically\n\
4807  generates a suitable tick interval.\n\
4808 \n\
4809  nysub (PLINT, input) : Number of subintervals between major y axis\n\
4810  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4811  generates a suitable minor tick interval.\n\
4812 ";
4813 static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4814 Get parameters that define current device-space window\n\
4815 \n\
4816 DESCRIPTION:\n\
4817 \n\
4818  Get relative margin width, aspect ratio, and relative justification\n\
4819  that define current device-space window. If plsdidev has not been\n\
4820  called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4821  p_jy will all be 0.\n\
4822 \n\
4823  Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4824 \n\
4825  This function is used in example 31.\n\
4826 \n\
4827 \n\
4828 \n\
4829 SYNOPSIS:\n\
4830 \n\
4831 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4832 \n\
4833 ARGUMENTS:\n\
4834 \n\
4835  p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4836  margin width.\n\
4837 \n\
4838  p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4839  ratio.\n\
4840 \n\
4841  p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4842  justification in x.\n\
4843 \n\
4844  p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4845  justification in y.\n\
4846 ";
4847 static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4848 Plot a glyph at the specified points\n\
4849 \n\
4850 DESCRIPTION:\n\
4851 \n\
4852  Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4853  because many[!] more glyphs are accessible with plstring.) The glyph\n\
4854  is specified with a PLplot user string. Note that the user string is\n\
4855  not actually limited to one glyph so it is possible (but not normally\n\
4856  useful) to plot more than one glyph at the specified points with this\n\
4857  function. As with plmtex and plptex, the user string can contain FCI\n\
4858  escapes to determine the font, UTF-8 code to determine the glyph or\n\
4859  else PLplot escapes for Hershey or unicode text to determine the\n\
4860  glyph.\n\
4861 \n\
4862  Redacted form: plstring(x, y, string)\n\
4863 \n\
4864  This function is used in examples 4, 21 and 26.\n\
4865 \n\
4866 \n\
4867 \n\
4868 SYNOPSIS:\n\
4869 \n\
4870 plstring(n, x, y, string)\n\
4871 \n\
4872 ARGUMENTS:\n\
4873 \n\
4874  n (PLINT, input) : Number of points in the x and y vectors.\n\
4875 \n\
4876  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4877  the points.\n\
4878 \n\
4879  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4880  the points.\n\
4881 \n\
4882  string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4883  the glyph(s) to be plotted at each of the n points.\n\
4884 ";
4885 static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
4886 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4887 \n\
4888 DESCRIPTION:\n\
4889 \n\
4890  As per plmapline, however the items are plotted as strings or points\n\
4891  in the same way as plstring.\n\
4892 \n\
4893  Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4894  maxy, plotentries)\n\
4895 \n\
4896  This function is not used in any examples.\n\
4897 \n\
4898 \n\
4899 \n\
4900 SYNOPSIS:\n\
4901 \n\
4902 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4903 \n\
4904 ARGUMENTS:\n\
4905 \n\
4906  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4907  transform the coordinates given in the shapefile into a plot\n\
4908  coordinate system. By using this transform, we can change from a\n\
4909  longitude, latitude coordinate to a polar stereographic project,\n\
4910  for example. Initially, x[0]..[n-1] are the longitudes and\n\
4911  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4912  mapform(), x[] and y[] should be replaced by the corresponding\n\
4913  plot coordinates. If no transform is desired, mapform can be\n\
4914  replaced by NULL.\n\
4915 \n\
4916  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4917  the file name of a set of Shapefile files without the file\n\
4918  extension.\n\
4919 \n\
4920  string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
4921  drawn.\n\
4922 \n\
4923  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
4924  be in the same units as used by the Shapefile. You could use a\n\
4925  very large negative number to plot everything, but you can improve\n\
4926  performance by limiting the area drawn. The units must match those\n\
4927  of the Shapefile projection, which may be for example longitude or\n\
4928  distance. The value of minx must be less than the value of maxx.\n\
4929 \n\
4930  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
4931  use a very large number to plot everything, but you can improve\n\
4932  performance by limiting the area drawn.\n\
4933 \n\
4934  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
4935  be in the same units as used by the Shapefile. You could use a\n\
4936  very large negative number to plot everything, but you can improve\n\
4937  performance by limiting the area drawn. The units must match those\n\
4938  of the Shapefile projection, which may be for example latitude or\n\
4939  distance. The value of miny must be less than the value of maxy.\n\
4940 \n\
4941  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
4942  use a very large number to plot everything, but you can improve\n\
4943  performance by limiting the area drawn.\n\
4944 \n\
4945  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
4946  zero-based indices of the Shapefile elements which will be drawn.\n\
4947  Setting\n\
4948  plotentries to NULL will plot all elements of the Shapefile.\n\
4949 \n\
4950  nplotentries (PLINT, input) : The number of items in\n\
4951  plotentries. Ignored if\n\
4952  plotentries is NULL.\n\
4953 ";
4954 static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
4955 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
4956 \n\
4957 DESCRIPTION:\n\
4958 \n\
4959  Sets up plotter environment for simple graphs by calling pladv and\n\
4960  setting up viewport and window to sensible default values. plenv0\n\
4961  leaves a standard margin (left-hand margin of eight character heights,\n\
4962  and a margin around the other three sides of five character heights)\n\
4963  around most graphs for axis labels and a title. When these defaults\n\
4964  are not suitable, use the individual routines plvpas, plvpor, or\n\
4965  plvasp for setting up the viewport, plwind for defining the window,\n\
4966  and plbox for drawing the box.\n\
4967 \n\
4968  Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4969 \n\
4970  This function is used in example 21.\n\
4971 \n\
4972 \n\
4973 \n\
4974 SYNOPSIS:\n\
4975 \n\
4976 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4977 \n\
4978 ARGUMENTS:\n\
4979 \n\
4980  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4981  world coordinates).\n\
4982 \n\
4983  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4984  world coordinates).\n\
4985 \n\
4986  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4987  coordinates).\n\
4988 \n\
4989  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4990  coordinates).\n\
4991 \n\
4992  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4993  scales will not be set, the user must set up the scale before\n\
4994  calling plenv0 using plsvpa, plvasp or other.\n\
4995  0: the x and y axes are scaled independently to use as much of\n\
4996  the screen as possible.\n\
4997  1: the scales of the x and y axes are made equal.\n\
4998  2: the axis of the x and y axes are made equal, and the plot\n\
4999  box will be square.\n\
5000 \n\
5001 \n\
5002  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
5003  -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
5004  -1: draw box only.\n\
5005  0: draw box, ticks, and numeric tick labels.\n\
5006  1: also draw coordinate axes at x=0 and y=0.\n\
5007  2: also draw a grid at major tick positions in both\n\
5008  coordinates.\n\
5009  3: also draw a grid at minor tick positions in both\n\
5010  coordinates.\n\
5011  10: same as 0 except logarithmic x tick marks. (The x data\n\
5012  have to be converted to logarithms separately.)\n\
5013  11: same as 1 except logarithmic x tick marks. (The x data\n\
5014  have to be converted to logarithms separately.)\n\
5015  12: same as 2 except logarithmic x tick marks. (The x data\n\
5016  have to be converted to logarithms separately.)\n\
5017  13: same as 3 except logarithmic x tick marks. (The x data\n\
5018  have to be converted to logarithms separately.)\n\
5019  20: same as 0 except logarithmic y tick marks. (The y data\n\
5020  have to be converted to logarithms separately.)\n\
5021  21: same as 1 except logarithmic y tick marks. (The y data\n\
5022  have to be converted to logarithms separately.)\n\
5023  22: same as 2 except logarithmic y tick marks. (The y data\n\
5024  have to be converted to logarithms separately.)\n\
5025  23: same as 3 except logarithmic y tick marks. (The y data\n\
5026  have to be converted to logarithms separately.)\n\
5027  30: same as 0 except logarithmic x and y tick marks. (The x\n\
5028  and y data have to be converted to logarithms separately.)\n\
5029  31: same as 1 except logarithmic x and y tick marks. (The x\n\
5030  and y data have to be converted to logarithms separately.)\n\
5031  32: same as 2 except logarithmic x and y tick marks. (The x\n\
5032  and y data have to be converted to logarithms separately.)\n\
5033  33: same as 3 except logarithmic x and y tick marks. (The x\n\
5034  and y data have to be converted to logarithms separately.)\n\
5035  40: same as 0 except date / time x labels.\n\
5036  41: same as 1 except date / time x labels.\n\
5037  42: same as 2 except date / time x labels.\n\
5038  43: same as 3 except date / time x labels.\n\
5039  50: same as 0 except date / time y labels.\n\
5040  51: same as 1 except date / time y labels.\n\
5041  52: same as 2 except date / time y labels.\n\
5042  53: same as 3 except date / time y labels.\n\
5043  60: same as 0 except date / time x and y labels.\n\
5044  61: same as 1 except date / time x and y labels.\n\
5045  62: same as 2 except date / time x and y labels.\n\
5046  63: same as 3 except date / time x and y labels.\n\
5047  70: same as 0 except custom x and y labels.\n\
5048  71: same as 1 except custom x and y labels.\n\
5049  72: same as 2 except custom x and y labels.\n\
5050  73: same as 3 except custom x and y labels.\n\
5051 ";
5052 static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
5053 Configure the transformations required for projecting a 3D surface on a 2D window\n\
5054 \n\
5055 DESCRIPTION:\n\
5056 \n\
5057  Configure the transformations required for projecting a 3D surface on\n\
5058  an existing 2D window. Those transformations (see the PLplot\n\
5059  documentation) are done to a rectangular cuboid enclosing the 3D\n\
5060  surface which has its limits expressed in 3D world coordinates and\n\
5061  also normalized 3D coordinates (used for interpreting the altitude and\n\
5062  azimuth of the viewing angle). The transformations consist of the\n\
5063  linear transform from 3D world coordinates to normalized 3D\n\
5064  coordinates, and the 3D rotation of normalized coordinates required to\n\
5065  align the pole of the new 3D coordinate system with the viewing\n\
5066  direction specified by altitude and azimuth so that x and y of the\n\
5067  surface elements in that transformed coordinate system are the\n\
5068  projection of the 3D surface with given viewing direction on the 2D\n\
5069  window.\n\
5070 \n\
5071  The enclosing rectangular cuboid for the surface plot is defined by\n\
5072  xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
5073  mapped into the same rectangular cuboid with normalized 3D coordinate\n\
5074  sizes of basex by basey by height so that xmin maps to -\n\
5075  basex/2, xmax maps to basex/2, ymin maps to -\n\
5076  basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
5077  The resulting rectangular cuboid in normalized coordinates is then\n\
5078  viewed by an observer at altitude alt and azimuth az. This routine\n\
5079  must be called before plbox3 or any of the 3D surface plotting\n\
5080  routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
5081  plsurf3dl or plfill3.\n\
5082 \n\
5083  Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
5084  zmin, zmax, alt, az)\n\
5085 \n\
5086  This function is examples 8, 11, 18, and 21.\n\
5087 \n\
5088 \n\
5089 \n\
5090 SYNOPSIS:\n\
5091 \n\
5092 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
5093 \n\
5094 ARGUMENTS:\n\
5095 \n\
5096  basex (PLFLT, input) : The normalized x coordinate size of the\n\
5097  rectangular cuboid.\n\
5098 \n\
5099  basey (PLFLT, input) : The normalized y coordinate size of the\n\
5100  rectangular cuboid.\n\
5101 \n\
5102  height (PLFLT, input) : The normalized z coordinate size of the\n\
5103  rectangular cuboid.\n\
5104 \n\
5105  xmin (PLFLT, input) : The minimum x world coordinate of the\n\
5106  rectangular cuboid.\n\
5107 \n\
5108  xmax (PLFLT, input) : The maximum x world coordinate of the\n\
5109  rectangular cuboid.\n\
5110 \n\
5111  ymin (PLFLT, input) : The minimum y world coordinate of the\n\
5112  rectangular cuboid.\n\
5113 \n\
5114  ymax (PLFLT, input) : The maximum y world coordinate of the\n\
5115  rectangular cuboid.\n\
5116 \n\
5117  zmin (PLFLT, input) : The minimum z world coordinate of the\n\
5118  rectangular cuboid.\n\
5119 \n\
5120  zmax (PLFLT, input) : The maximum z world coordinate of the\n\
5121  rectangular cuboid.\n\
5122 \n\
5123  alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
5124  plane of the rectangular cuboid in normalized coordinates.\n\
5125 \n\
5126  az (PLFLT, input) : The viewing azimuth in degrees of the\n\
5127  rectangular cuboid in normalized coordinates. When az=0, the\n\
5128  observer is looking face onto the zx plane of the rectangular\n\
5129  cuboid in normalized coordinates, and as az is increased, the\n\
5130  observer moves clockwise around that cuboid when viewed from above\n\
5131  the xy plane.\n\
5132 ";
5133 static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
5134 Draw filled polygon\n\
5135 \n\
5136 DESCRIPTION:\n\
5137 \n\
5138  Fills the polygon defined by the n points (\n\
5139  x[i],\n\
5140  y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
5141  style is a solid fill. The routine will automatically close the\n\
5142  polygon between the last and first vertices. If multiple closed\n\
5143  polygons are passed in x and y then plfill will fill in between them.\n\
5144 \n\
5145  Redacted form: plfill(x,y)\n\
5146 \n\
5147  This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
5148 \n\
5149 \n\
5150 \n\
5151 SYNOPSIS:\n\
5152 \n\
5153 plfill(n, x, y)\n\
5154 \n\
5155 ARGUMENTS:\n\
5156 \n\
5157  n (PLINT, input) : Number of vertices in polygon.\n\
5158 \n\
5159  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5160  vertices.\n\
5161 \n\
5162  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5163  vertices.\n\
5164 ";
5165 static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
5166 Magnitude colored plot surface with contour\n\
5167 \n\
5168 DESCRIPTION:\n\
5169 \n\
5170  Aside from dropping the\n\
5171  side functionality this is a more powerful form of plot3d: the surface\n\
5172  mesh can be colored accordingly to the current z value being plotted,\n\
5173  a contour plot can be drawn at the base XY plane, and a curtain can be\n\
5174  drawn between the plotted function border and the base XY plane. The\n\
5175  arguments are identical to those of plmeshc. The only difference\n\
5176  between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
5177  the surface, while plot3dc only draws the surface as viewed from the\n\
5178  top.\n\
5179 \n\
5180  Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
5181 \n\
5182 \n\
5183  This function is used in example 21.\n\
5184 \n\
5185 \n\
5186 \n\
5187 SYNOPSIS:\n\
5188 \n\
5189 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
5190 \n\
5191 ARGUMENTS:\n\
5192 \n\
5193  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5194  which the function is evaluated.\n\
5195 \n\
5196  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5197  which the function is evaluated.\n\
5198 \n\
5199  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5200  plot. Should have dimensions of\n\
5201  nx by\n\
5202  ny.\n\
5203 \n\
5204  nx (PLINT, input) : Number of x values at which function is\n\
5205  evaluated.\n\
5206 \n\
5207  ny (PLINT, input) : Number of y values at which function is\n\
5208  evaluated.\n\
5209 \n\
5210  opt (PLINT, input) : Determines the way in which the surface is\n\
5211  represented. To specify more than one option just add the options,\n\
5212  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
5213  showing z as a function of x for each value of y[j] .\n\
5214  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5215  for each value of x[i] .\n\
5216  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5217  at which function is defined.\n\
5218  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
5219  the z value being plotted. The color is used from the current\n\
5220  cmap1.\n\
5221  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5222  using parameters\n\
5223  nlevel and\n\
5224  clevel.\n\
5225  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5226  the borders of the plotted function.\n\
5227 \n\
5228 \n\
5229  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5230  levels.\n\
5231 \n\
5232  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5233 ";
5234 static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
5235 Write text relative to viewport boundaries\n\
5236 \n\
5237 DESCRIPTION:\n\
5238 \n\
5239  Writes text at a specified position relative to the viewport\n\
5240  boundaries. Text may be written inside or outside the viewport, but\n\
5241  is clipped at the subpage boundaries. The reference point of a string\n\
5242  lies along a line passing through the string at half the height of a\n\
5243  capital letter. The position of the reference point along this line\n\
5244  is determined by just, and the position of the reference point\n\
5245  relative to the viewport is set by disp and pos.\n\
5246 \n\
5247  Redacted form: General: plmtex(side, disp, pos, just, text)\n\
5248 \n\
5249 \n\
5250  This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
5251  26.\n\
5252 \n\
5253 \n\
5254 \n\
5255 SYNOPSIS:\n\
5256 \n\
5257 plmtex(side, disp, pos, just, text)\n\
5258 \n\
5259 ARGUMENTS:\n\
5260 \n\
5261  side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5262  the side of the viewport along which the text is to be written.\n\
5263  The string must be one of: b: Bottom of viewport, text written\n\
5264  parallel to edge.\n\
5265  bv: Bottom of viewport, text written at right angles to edge.\n\
5266  l: Left of viewport, text written parallel to edge.\n\
5267  lv: Left of viewport, text written at right angles to edge.\n\
5268  r: Right of viewport, text written parallel to edge.\n\
5269  rv: Right of viewport, text written at right angles to edge.\n\
5270  t: Top of viewport, text written parallel to edge.\n\
5271  tv: Top of viewport, text written at right angles to edge.\n\
5272 \n\
5273 \n\
5274  disp (PLFLT, input) : Position of the reference point of string,\n\
5275  measured outwards from the specified viewport edge in units of the\n\
5276  current character height. Use negative disp to write within the\n\
5277  viewport.\n\
5278 \n\
5279  pos (PLFLT, input) : Position of the reference point of string\n\
5280  along the specified edge, expressed as a fraction of the length of\n\
5281  the edge.\n\
5282 \n\
5283  just (PLFLT, input) : Specifies the position of the string relative\n\
5284  to its reference point. If just=0. , the reference point is at\n\
5285  the left and if just=1. , it is at the right of the string. Other\n\
5286  values of just give intermediate justifications.\n\
5287 \n\
5288  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5289  written out.\n\
5290 ";
5291 static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
5292 Set arrow style for vector plots\n\
5293 \n\
5294 DESCRIPTION:\n\
5295 \n\
5296  Set the style for the arrow used by plvect to plot vectors.\n\
5297 \n\
5298  Redacted form: plsvect(arrowx, arrowy, fill)\n\
5299 \n\
5300  This function is used in example 22.\n\
5301 \n\
5302 \n\
5303 \n\
5304 SYNOPSIS:\n\
5305 \n\
5306 plsvect(arrowx, arrowy, npts, fill)\n\
5307 \n\
5308 ARGUMENTS:\n\
5309 \n\
5310  arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
5311  the x and y points which make up the arrow. The arrow is plotted\n\
5312  by joining these points to form a polygon. The scaling assumes\n\
5313  that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
5314  <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
5315  will be reset to its default.\n\
5316 \n\
5317  npts (PLINT, input) : Number of points in the vectors arrowx and\n\
5318  arrowy.\n\
5319 \n\
5320  fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
5321  fill is false then the arrow is open.\n\
5322 ";
5323 static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5324 Get family file parameters\n\
5325 \n\
5326 DESCRIPTION:\n\
5327 \n\
5328  Gets information about current family file, if familying is enabled.\n\
5329  See the PLplot documentation for more information.\n\
5330 \n\
5331  Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5332 \n\
5333  This function is used in examples 14 and 31.\n\
5334 \n\
5335 \n\
5336 \n\
5337 SYNOPSIS:\n\
5338 \n\
5339 plgfam(p_fam, p_num, p_bmax)\n\
5340 \n\
5341 ARGUMENTS:\n\
5342 \n\
5343  p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5344  family flag value. If nonzero, familying is enabled for the\n\
5345  current device.\n\
5346 \n\
5347  p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5348  family file number.\n\
5349 \n\
5350  p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5351  file size (in bytes) for a family file.\n\
5352 ";
5353 static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
5354 Random number generator returning a real random number in the range [0,1]\n\
5355 \n\
5356 DESCRIPTION:\n\
5357 \n\
5358  Random number generator returning a real random number in the range\n\
5359  [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5360  / compilers provide their own random number generator, and so this is\n\
5361  provided purely for convenience and to give a consistent random number\n\
5362  generator across all languages supported by PLplot. This is\n\
5363  particularly useful for comparing results from the test suite of\n\
5364  examples.\n\
5365 \n\
5366  Redacted form: plrandd()\n\
5367 \n\
5368  This function is used in examples 17 and 21.\n\
5369 \n\
5370 \n\
5371 \n\
5372 SYNOPSIS:\n\
5373 \n\
5374 plrandd()\n\
5375 ";
5376 static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5377 Contour plot\n\
5378 \n\
5379 DESCRIPTION:\n\
5380 \n\
5381  Draws a contour plot of the data in f[\n\
5382  nx][\n\
5383  ny], using the nlevel contour levels specified by clevel. Only the\n\
5384  region of the matrix from kx to lx and from ky to ly is plotted out\n\
5385  where all these index ranges are interpreted as one-based for\n\
5386  historical reasons. A transformation routine pointed to by pltr with\n\
5387  a generic pointer pltr_data for additional data required by the\n\
5388  transformation routine is used to map indices within the matrix to the\n\
5389  world coordinates.\n\
5390 \n\
5391  Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5392  where (see above discussion) the pltr, pltr_data callback arguments\n\
5393  are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5394  vectors; or xg and yg matrices.\n\
5395 \n\
5396  This function is used in examples 9, 14, 16, and 22.\n\
5397 \n\
5398 \n\
5399 \n\
5400 SYNOPSIS:\n\
5401 \n\
5402 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5403 \n\
5404 ARGUMENTS:\n\
5405 \n\
5406  f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5407 \n\
5408  nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5409 \n\
5410  kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5411  kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5412  zero-based for historical backwards-compatibility reasons.\n\
5413 \n\
5414  ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5415  ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5416  zero-based for historical backwards-compatibility reasons.\n\
5417 \n\
5418  clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5419  which to draw contours.\n\
5420 \n\
5421  nlevel (PLINT, input) : Number of contour levels to draw.\n\
5422 \n\
5423  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5424  defines the transformation between the zero-based indices of the\n\
5425  matrix f and the world coordinates.For the C case, transformation\n\
5426  functions are provided in the PLplot library: pltr0 for the\n\
5427  identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5428  respectively defined by vectors and matrices. In addition, C\n\
5429  callback routines for the transformation can be supplied by the\n\
5430  user such as the mypltr function in examples/c/x09c.c which\n\
5431  provides a general linear transformation between index coordinates\n\
5432  and world coordinates.For languages other than C you should\n\
5433  consult the PLplot documentation for the details concerning how\n\
5434  PLTRANSFORM_callback arguments are interfaced. However, in\n\
5435  general, a particular pattern of callback-associated arguments\n\
5436  such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5437  yg matrices are respectively interfaced to a linear-transformation\n\
5438  routine similar to the above mypltr function; pltr1; and pltr2.\n\
5439  Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5440  the PLplot documentation) support native language callbacks for\n\
5441  handling index to world-coordinate transformations. Examples of\n\
5442  these various approaches are given in examples/<language>x09*,\n\
5443  examples/<language>x16*, examples/<language>x20*,\n\
5444  examples/<language>x21*, and examples/<language>x22*, for all our\n\
5445  supported languages.\n\
5446 \n\
5447  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5448  information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5449  that is externally supplied.\n\
5450 ";
5451 static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
5452 Set line style\n\
5453 \n\
5454 DESCRIPTION:\n\
5455 \n\
5456  This sets up the line style for all lines subsequently drawn. A line\n\
5457  consists of segments in which the pen is alternately down and up. The\n\
5458  lengths of these segments are passed in the vectors mark and space\n\
5459  respectively. The number of mark-space pairs is specified by nms. In\n\
5460  order to return the line style to the default continuous line, plstyl\n\
5461  should be called with nms =0 .(see also pllsty)\n\
5462 \n\
5463  Redacted form: plstyl(mark, space)\n\
5464 \n\
5465  This function is used in examples 1, 9, and 14.\n\
5466 \n\
5467 \n\
5468 \n\
5469 SYNOPSIS:\n\
5470 \n\
5471 plstyl(nms, mark, space)\n\
5472 \n\
5473 ARGUMENTS:\n\
5474 \n\
5475  nms (PLINT, input) : The number of mark and space elements in a\n\
5476  line. Thus a simple broken line can be obtained by setting nms=1\n\
5477  . A continuous line is specified by setting nms=0 .\n\
5478 \n\
5479  mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5480  segments during which the pen is down, measured in micrometers.\n\
5481 \n\
5482  space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5483  the segments during which the pen is up, measured in micrometers.\n\
5484 ";
5485 static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
5486 Set the cmap0 palette using the specified cmap0*.pal format file\n\
5487 \n\
5488 DESCRIPTION:\n\
5489 \n\
5490  Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5491 \n\
5492  Redacted form: plspal0(filename)\n\
5493 \n\
5494  This function is in example 16.\n\
5495 \n\
5496 \n\
5497 \n\
5498 SYNOPSIS:\n\
5499 \n\
5500 plspal0(filename)\n\
5501 \n\
5502 ARGUMENTS:\n\
5503 \n\
5504  filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5505  containing the name of the cmap0*.pal file. If this string is\n\
5506  empty, use the default cmap0*.pal file.\n\
5507 ";
5508 static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
5509 Set the cmap1 palette using the specified cmap1*.pal format file\n\
5510 \n\
5511 DESCRIPTION:\n\
5512 \n\
5513  Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5514 \n\
5515  Redacted form: plspal1(filename, interpolate)\n\
5516 \n\
5517  This function is used in example 16.\n\
5518 \n\
5519 \n\
5520 \n\
5521 SYNOPSIS:\n\
5522 \n\
5523 plspal1(filename, interpolate)\n\
5524 \n\
5525 ARGUMENTS:\n\
5526 \n\
5527  filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5528  containing the name of the cmap1*.pal file. If this string is\n\
5529  empty, use the default cmap1*.pal file.\n\
5530 \n\
5531  interpolate (PLBOOL, input) : If this parameter is true, the\n\
5532  columns containing the intensity index, r, g, b, alpha and\n\
5533  alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5534  palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5535  a flag which controls whether the r, g, b data sent to plscmap1la\n\
5536  are interpreted as HLS or RGB.) If this parameter is false, the\n\
5537  intensity index and alt_hue_path columns are ignored and the r, g,\n\
5538  b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5539  are used instead to set the cmap1 palette directly with a call to\n\
5540  plscmap1a.\n\
5541 ";
5542 static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
5543 Set current output stream\n\
5544 \n\
5545 DESCRIPTION:\n\
5546 \n\
5547  Sets the number of the current output stream. The stream number\n\
5548  defaults to 0 unless changed by this routine. The first use of this\n\
5549  routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5550 \n\
5551  Redacted form: plsstrm(strm)\n\
5552 \n\
5553  This function is examples 1,14,20.\n\
5554 \n\
5555 \n\
5556 \n\
5557 SYNOPSIS:\n\
5558 \n\
5559 plsstrm(strm)\n\
5560 \n\
5561 ARGUMENTS:\n\
5562 \n\
5563  strm (PLINT, input) : The current stream number.\n\
5564 ";
5565 static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
5566 Specify viewport using normalized subpage coordinates\n\
5567 \n\
5568 DESCRIPTION:\n\
5569 \n\
5570  Device-independent routine for setting up the viewport. This defines\n\
5571  the viewport in terms of normalized subpage coordinates which run from\n\
5572  0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5573  current subpage. Use the alternate routine plsvpa in order to create\n\
5574  a viewport of a definite size.\n\
5575 \n\
5576  Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5577 \n\
5578  This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5579  24, 26, 27, and 31.\n\
5580 \n\
5581 \n\
5582 \n\
5583 SYNOPSIS:\n\
5584 \n\
5585 plvpor(xmin, xmax, ymin, ymax)\n\
5586 \n\
5587 ARGUMENTS:\n\
5588 \n\
5589  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5590  left-hand edge of the viewport.\n\
5591 \n\
5592  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5593  right-hand edge of the viewport.\n\
5594 \n\
5595  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5596  bottom edge of the viewport.\n\
5597 \n\
5598  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5599  edge of the viewport.\n\
5600 ";
5601 static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
5602 Write text inside the viewport\n\
5603 \n\
5604 DESCRIPTION:\n\
5605 \n\
5606  Writes text at a specified position and inclination within the\n\
5607  viewport. Text is clipped at the viewport boundaries. The reference\n\
5608  point of a string lies along a line passing through the string at half\n\
5609  the height of a capital letter. The position of the reference point\n\
5610  along this line is determined by just, the reference point is placed\n\
5611  at world coordinates (\n\
5612  x,\n\
5613  y) within the viewport. The inclination of the string is specified\n\
5614  in terms of differences of world coordinates making it easy to write\n\
5615  text parallel to a line in a graph.\n\
5616 \n\
5617  Redacted form: plptex(x, y, dx, dy, just, text)\n\
5618 \n\
5619  This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5620 \n\
5621 \n\
5622 \n\
5623 SYNOPSIS:\n\
5624 \n\
5625 plptex(x, y, dx, dy, just, text)\n\
5626 \n\
5627 ARGUMENTS:\n\
5628 \n\
5629  x (PLFLT, input) : x coordinate of reference point of string.\n\
5630 \n\
5631  y (PLFLT, input) : y coordinate of reference point of string.\n\
5632 \n\
5633  dx (PLFLT, input) : Together with dy, this specifies the\n\
5634  inclination of the string. The baseline of the string is parallel\n\
5635  to a line joining (\n\
5636  x,\n\
5637  y) to (\n\
5638  x+\n\
5639  dx,\n\
5640  y+\n\
5641  dy) .\n\
5642 \n\
5643  dy (PLFLT, input) : Together with dx, this specifies the\n\
5644  inclination of the string.\n\
5645 \n\
5646  just (PLFLT, input) : Specifies the position of the string relative\n\
5647  to its reference point. If just=0. , the reference point is at\n\
5648  the left and if just=1. , it is at the right of the string. Other\n\
5649  values of just give intermediate justifications.\n\
5650 \n\
5651  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5652  written out.\n\
5653 ";
5654 static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
5655 Set z axis parameters\n\
5656 \n\
5657 DESCRIPTION:\n\
5658 \n\
5659  Identical to plsxax, except that arguments are flags for z axis. See\n\
5660  the description of plsxax for more detail.\n\
5661 \n\
5662  Redacted form: plszax(digmax, digits)\n\
5663 \n\
5664  This function is used in example 31.\n\
5665 \n\
5666 \n\
5667 \n\
5668 SYNOPSIS:\n\
5669 \n\
5670 plszax(digmax, digits)\n\
5671 \n\
5672 ARGUMENTS:\n\
5673 \n\
5674  digmax (PLINT, input) : Variable to set the maximum number of\n\
5675  digits for the z axis. If nonzero, the printed label will be\n\
5676  switched to a floating-point representation when the number of\n\
5677  digits exceeds digmax.\n\
5678 \n\
5679  digits (PLINT, input) : Field digits value. Currently, changing\n\
5680  its value here has no effect since it is set only by plbox or\n\
5681  plbox3. However, the user may obtain its value after a call to\n\
5682  either of these functions by calling plgzax.\n\
5683 ";
5684 static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
5685 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5686 \n\
5687 DESCRIPTION:\n\
5688 \n\
5689  This variant of plsurf3d (see that function\'s documentation for more\n\
5690  details) should be suitable for the case where the area of the x, y\n\
5691  coordinate grid where z is defined can be non-rectangular. The limits\n\
5692  of that grid are provided by the parameters indexxmin, indexxmax,\n\
5693  indexymin, and indexymax.\n\
5694 \n\
5695  Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5696  indexymax)\n\
5697 \n\
5698  This function is used in example 8.\n\
5699 \n\
5700 \n\
5701 \n\
5702 SYNOPSIS:\n\
5703 \n\
5704 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5705 \n\
5706 ARGUMENTS:\n\
5707 \n\
5708  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5709  which the function is evaluated.\n\
5710 \n\
5711  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5712  which the function is evaluated.\n\
5713 \n\
5714  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5715  plot. Should have dimensions of\n\
5716  nx by\n\
5717  ny.\n\
5718 \n\
5719  nx (PLINT, input) : Number of x values at which function is\n\
5720  evaluated.\n\
5721 \n\
5722  ny (PLINT, input) : Number of y values at which function is\n\
5723  evaluated.\n\
5724 \n\
5725  opt (PLINT, input) : Determines the way in which the surface is\n\
5726  represented. To specify more than one option just add the options,\n\
5727  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5728  connecting points at which function is defined.\n\
5729  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5730  using parameters\n\
5731  nlevel and\n\
5732  clevel.\n\
5733  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5734  using parameters\n\
5735  nlevel and\n\
5736  clevel.\n\
5737  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5738  the borders of the plotted function.\n\
5739  opt=MAG_COLOR : the surface is colored according to the value\n\
5740  of Z; if MAG_COLOR is not used, then the surface is colored\n\
5741  according to the intensity of the reflected light in the\n\
5742  surface from a light source whose position is set using\n\
5743  pllightsource.\n\
5744 \n\
5745 \n\
5746  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5747  levels.\n\
5748 \n\
5749  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5750 \n\
5751  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5752  corresponds to the first x index where z is defined.\n\
5753 \n\
5754  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5755  which corresponds (by convention) to one more than the last x\n\
5756  index value where z is defined.\n\
5757 \n\
5758  indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5759  values which all must be ≥ 0. These values are the first y index\n\
5760  where z is defined for a particular x index in the range from\n\
5761  indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5762  indexxmax.\n\
5763 \n\
5764  indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5765  values which all must be ≤ ny. These values correspond (by\n\
5766  convention) to one more than the last y index where z is defined\n\
5767  for a particular x index in the range from indexxmin to indexxmax\n\
5768  - 1. The dimension of indexymax is indexxmax.\n\
5769 ";
5770 static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
5771 Set font\n\
5772 \n\
5773 DESCRIPTION:\n\
5774 \n\
5775  Sets the font used for subsequent text and symbols. For devices that\n\
5776  still use Hershey fonts this routine has no effect unless the Hershey\n\
5777  fonts with extended character set are loaded (see plfontld). For\n\
5778  unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5779  this routine calls the plsfci routine with argument set up\n\
5780  appropriately for the various cases below. However, this method of\n\
5781  specifying the font for unicode-aware devices is deprecated, and the\n\
5782  much more flexible method of calling plsfont directly is recommended\n\
5783  instead (where plsfont provides a user-friendly interface to plsfci),\n\
5784 \n\
5785  Redacted form: plfont(ifont)\n\
5786 \n\
5787  This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5788 \n\
5789 \n\
5790 \n\
5791 SYNOPSIS:\n\
5792 \n\
5793 plfont(ifont)\n\
5794 \n\
5795 ARGUMENTS:\n\
5796 \n\
5797  ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5798  (simplest and fastest)\n\
5799  2: Serif font\n\
5800  3: Italic font\n\
5801  4: Script font\n\
5802 ";
5803 static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
5804 Get the cmap1 argument range for continuous color plots\n\
5805 \n\
5806 DESCRIPTION:\n\
5807 \n\
5808  Get the cmap1 argument range for continuous color plots. (Use\n\
5809  plscmap1_range to set the cmap1 argument range.)\n\
5810 \n\
5811  Redacted form: plgcmap1_range(min_color, max_color)\n\
5812 \n\
5813  This function is currently not used in any example.\n\
5814 \n\
5815 \n\
5816 \n\
5817 SYNOPSIS:\n\
5818 \n\
5819 plgcmap1_range(min_color, max_color)\n\
5820 \n\
5821 ARGUMENTS:\n\
5822 \n\
5823  min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5824  minimum cmap1 argument.\n\
5825 \n\
5826  max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5827  maximum cmap1 argument.\n\
5828 ";
5829 static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
5830 Set the cmap1 argument range for continuous color plots\n\
5831 \n\
5832 DESCRIPTION:\n\
5833 \n\
5834  Set the cmap1 argument range for continuous color plots that\n\
5835  corresponds to the range of data values. The maximum range\n\
5836  corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5837  the cmap1 argument range that is specified with this routine, the\n\
5838  smaller the subset of the cmap1 color palette that is used to\n\
5839  represent the continuous data being plotted. If\n\
5840  min_color is greater than\n\
5841  max_color or\n\
5842  max_color is greater than 1.0 or\n\
5843  min_color is less than 0.0 then no change is made to the cmap1\n\
5844  argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5845 \n\
5846  Redacted form: plscmap1_range(min_color, max_color)\n\
5847 \n\
5848  This function is currently used in example 33.\n\
5849 \n\
5850 \n\
5851 \n\
5852 SYNOPSIS:\n\
5853 \n\
5854 plscmap1_range(min_color, max_color)\n\
5855 \n\
5856 ARGUMENTS:\n\
5857 \n\
5858  min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5859  than 0.0, then 0.0 is used instead.\n\
5860 \n\
5861  max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5862  than 1.0, then 1.0 is used instead.\n\
5863 ";
5864 static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
5865 Draw a circular or elliptical arc\n\
5866 \n\
5867 DESCRIPTION:\n\
5868 \n\
5869  Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5870  semiminor axis b, starting at angle1 and ending at angle2.\n\
5871 \n\
5872  Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5873  fill)\n\
5874 \n\
5875 \n\
5876  This function is used in examples 3 and 27.\n\
5877 \n\
5878 \n\
5879 \n\
5880 SYNOPSIS:\n\
5881 \n\
5882 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5883 \n\
5884 ARGUMENTS:\n\
5885 \n\
5886  x (PLFLT, input) : X coordinate of arc center.\n\
5887 \n\
5888  y (PLFLT, input) : Y coordinate of arc center.\n\
5889 \n\
5890  a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5891 \n\
5892  b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5893 \n\
5894  angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5895  semimajor axis.\n\
5896 \n\
5897  angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5898  semimajor axis.\n\
5899 \n\
5900  rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5901  X-axis.\n\
5902 \n\
5903  fill (PLBOOL, input) : Draw a filled arc.\n\
5904 ";
5905 static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5906 Plot 3-d surface plot\n\
5907 \n\
5908 DESCRIPTION:\n\
5909 \n\
5910  Plots a three-dimensional surface plot within the environment set up\n\
5911  by plw3d. The surface is defined by the matrix z[\n\
5912  nx][\n\
5913  ny] , the point z[i][j] being the value of the function at (\n\
5914  x[i],\n\
5915  y[j]). Note that the points in vectors x and y do not need to be\n\
5916  equally spaced, but must be stored in ascending order. The parameter\n\
5917  opt controls the way in which the surface is displayed. For further\n\
5918  details see the PLplot documentation. The only difference between\n\
5919  plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5920  while plot3d only draws the surface as viewed from the top.\n\
5921 \n\
5922  Redacted form: plot3d(x, y, z, opt, side)\n\
5923 \n\
5924  This function is used in examples 11 and 21.\n\
5925 \n\
5926 \n\
5927 \n\
5928 SYNOPSIS:\n\
5929 \n\
5930 plot3d(x, y, z, nx, ny, opt, side)\n\
5931 \n\
5932 ARGUMENTS:\n\
5933 \n\
5934  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5935  which the function is evaluated.\n\
5936 \n\
5937  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5938  which the function is evaluated.\n\
5939 \n\
5940  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5941  plot. Should have dimensions of\n\
5942  nx by\n\
5943  ny.\n\
5944 \n\
5945  nx (PLINT, input) : Number of x values at which function is\n\
5946  evaluated.\n\
5947 \n\
5948  ny (PLINT, input) : Number of y values at which function is\n\
5949  evaluated.\n\
5950 \n\
5951  opt (PLINT, input) : Determines the way in which the surface is\n\
5952  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5953  function of x for each value of y[j] .\n\
5954  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5955  for each value of x[i] .\n\
5956  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5957  at which function is defined.\n\
5958 \n\
5959 \n\
5960  side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5961  should be draw on the figure. If side is true sides are drawn,\n\
5962  otherwise no sides are drawn.\n\
5963 ";
5964 static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5965 Set area line fill pattern\n\
5966 \n\
5967 DESCRIPTION:\n\
5968 \n\
5969  Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5970  The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5971  inclinations and spacings. The arguments to this routine are the\n\
5972  number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5973  elements) specifying the inclinations in tenths of a degree and the\n\
5974  spacing in micrometers. (See also plpsty)\n\
5975 \n\
5976  Redacted form: General: plpat(inc, del)\n\
5977 \n\
5978 \n\
5979  This function is used in example 15.\n\
5980 \n\
5981 \n\
5982 \n\
5983 SYNOPSIS:\n\
5984 \n\
5985 plpat(nlin, inc, del)\n\
5986 \n\
5987 ARGUMENTS:\n\
5988 \n\
5989  nlin (PLINT, input) : Number of sets of lines making up the\n\
5990  pattern, either 1 or 2.\n\
5991 \n\
5992  inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5993  inclination in tenths of a degree. (Should be between -900 and\n\
5994  900).\n\
5995 \n\
5996  del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5997  spacing in micrometers between the lines making up the pattern.\n\
5998 ";
5999 static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
6000 Get x axis parameters\n\
6001 \n\
6002 DESCRIPTION:\n\
6003 \n\
6004  Returns current values of the p_digmax and p_digits flags for the x\n\
6005  axis. p_digits is updated after the plot is drawn, so this routine\n\
6006  should only be called after the call to plbox (or plbox3) is complete.\n\
6007  See the PLplot documentation for more information.\n\
6008 \n\
6009  Redacted form: plgxax(p_digmax, p_digits)\n\
6010 \n\
6011  This function is used in example 31.\n\
6012 \n\
6013 \n\
6014 \n\
6015 SYNOPSIS:\n\
6016 \n\
6017 plgxax(p_digmax, p_digits)\n\
6018 \n\
6019 ARGUMENTS:\n\
6020 \n\
6021  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6022  number of digits for the x axis. If nonzero, the printed label\n\
6023  has been switched to a floating-point representation when the\n\
6024  number of digits exceeds this value.\n\
6025 \n\
6026  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6027  number of digits for the numeric labels (x axis) from the last\n\
6028  plot.\n\
6029 ";
6030 static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
6031 Draw filled polygon in 3D\n\
6032 \n\
6033 DESCRIPTION:\n\
6034 \n\
6035  Fills the 3D polygon defined by the n points in the x, y, and z\n\
6036  vectors using the pattern defined by plpsty or plpat. The routine\n\
6037  will automatically close the polygon between the last and first\n\
6038  vertices. If multiple closed polygons are passed in x, y, and z then\n\
6039  plfill3 will fill in between them.\n\
6040 \n\
6041  Redacted form: General: plfill3(x, y, z)\n\
6042 \n\
6043 \n\
6044  This function is used in example 15.\n\
6045 \n\
6046 \n\
6047 \n\
6048 SYNOPSIS:\n\
6049 \n\
6050 plfill3(n, x, y, z)\n\
6051 \n\
6052 ARGUMENTS:\n\
6053 \n\
6054  n (PLINT, input) : Number of vertices in polygon.\n\
6055 \n\
6056  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6057  vertices.\n\
6058 \n\
6059  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6060  vertices.\n\
6061 \n\
6062  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6063  vertices.\n\
6064 ";
6065 static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6066 Set color, cmap0\n\
6067 \n\
6068 DESCRIPTION:\n\
6069 \n\
6070  Sets the color index for cmap0 (see the PLplot documentation).\n\
6071 \n\
6072  Redacted form: plcol0(icol0)\n\
6073 \n\
6074  This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6075 \n\
6076 \n\
6077 \n\
6078 SYNOPSIS:\n\
6079 \n\
6080 plcol0(icol0)\n\
6081 \n\
6082 ARGUMENTS:\n\
6083 \n\
6084  icol0 (PLINT, input) : Integer representing the color. The\n\
6085  defaults at present are (these may change):\n\
6086  0 black (default background)\n\
6087  1 red (default foreground)\n\
6088  2 yellow\n\
6089  3 green\n\
6090  4 aquamarine\n\
6091  5 pink\n\
6092  6 wheat\n\
6093  7 grey\n\
6094  8 brown\n\
6095  9 blue\n\
6096  10 BlueViolet\n\
6097  11 cyan\n\
6098  12 turquoise\n\
6099  13 magenta\n\
6100  14 salmon\n\
6101  15 white\n\
6102 \n\
6103  Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6104  change an individual color in the cmap0 color palette.\n\
6105 ";
6106 static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
6107 Draw text at points defined by Shapefile data in world coordinates\n\
6108 \n\
6109 DESCRIPTION:\n\
6110 \n\
6111  As per plmapline, however the items are plotted as text in the same\n\
6112  way as plptex.\n\
6113 \n\
6114  Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
6115  miny, maxy, plotentry)\n\
6116 \n\
6117  This function is used in example 19.\n\
6118 \n\
6119 \n\
6120 \n\
6121 SYNOPSIS:\n\
6122 \n\
6123 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
6124 \n\
6125 ARGUMENTS:\n\
6126 \n\
6127  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6128  transform the coordinates given in the shapefile into a plot\n\
6129  coordinate system. By using this transform, we can change from a\n\
6130  longitude, latitude coordinate to a polar stereographic project,\n\
6131  for example. Initially, x[0]..[n-1] are the longitudes and\n\
6132  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6133  mapform(), x[] and y[] should be replaced by the corresponding\n\
6134  plot coordinates. If no transform is desired, mapform can be\n\
6135  replaced by NULL.\n\
6136 \n\
6137  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6138  the file name of a set of Shapefile files without the file\n\
6139  extension.\n\
6140 \n\
6141  dx (PLFLT, input) : Used to define the slope of the texts which is\n\
6142  dy/dx.\n\
6143 \n\
6144  dy (PLFLT, input) : Used to define the slope of the texts which is\n\
6145  dy/dx.\n\
6146 \n\
6147  just (PLFLT, input) : Set the justification of the text. The value\n\
6148  given will be the fraction of the distance along the string that\n\
6149  sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
6150  centralized text and 1.0 gives right aligned text.\n\
6151 \n\
6152  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
6153 \n\
6154  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6155  be in the same units as used by the Shapefile. You could use a\n\
6156  very large negative number to plot everything, but you can improve\n\
6157  performance by limiting the area drawn. The units must match those\n\
6158  of the Shapefile projection, which may be for example longitude or\n\
6159  distance. The value of minx must be less than the value of maxx.\n\
6160 \n\
6161  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6162  use a very large number to plot everything, but you can improve\n\
6163  performance by limiting the area drawn.\n\
6164 \n\
6165  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6166  be in the same units as used by the Shapefile. You could use a\n\
6167  very large negative number to plot everything, but you can improve\n\
6168  performance by limiting the area drawn. The units must match those\n\
6169  of the Shapefile projection, which may be for example latitude or\n\
6170  distance. The value of miny must be less than the value of maxy.\n\
6171 \n\
6172  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6173  use a very large number to plot everything, but you can improve\n\
6174  performance by limiting the area drawn.\n\
6175 \n\
6176  plotentry (PLINT, input) : An integer indicating which text string\n\
6177  of the Shapefile (zero indexed) will be drawn.\n\
6178 ";
6179 static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
6180 Draw a line between two points\n\
6181 \n\
6182 DESCRIPTION:\n\
6183 \n\
6184  Joins the point (\n\
6185  x1,\n\
6186  y1) to (\n\
6187  x2,\n\
6188  y2).\n\
6189 \n\
6190  Redacted form: pljoin(x1,y1,x2,y2)\n\
6191 \n\
6192  This function is used in examples 3 and 14.\n\
6193 \n\
6194 \n\
6195 \n\
6196 SYNOPSIS:\n\
6197 \n\
6198 pljoin(x1, y1, x2, y2)\n\
6199 \n\
6200 ARGUMENTS:\n\
6201 \n\
6202  x1 (PLFLT, input) : x coordinate of first point.\n\
6203 \n\
6204  y1 (PLFLT, input) : y coordinate of first point.\n\
6205 \n\
6206  x2 (PLFLT, input) : x coordinate of second point.\n\
6207 \n\
6208  y2 (PLFLT, input) : y coordinate of second point.\n\
6209 ";
6210 static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6211 Set color, cmap1\n\
6212 \n\
6213 DESCRIPTION:\n\
6214 \n\
6215  Sets the color for cmap1 (see the PLplot documentation).\n\
6216 \n\
6217  Redacted form: plcol1(col1)\n\
6218 \n\
6219  This function is used in examples 12 and 21.\n\
6220 \n\
6221 \n\
6222 \n\
6223 SYNOPSIS:\n\
6224 \n\
6225 plcol1(col1)\n\
6226 \n\
6227 ARGUMENTS:\n\
6228 \n\
6229  col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6230  is mapped to color using the continuous cmap1 palette which by\n\
6231  default ranges from blue to the background color to red. The\n\
6232  cmap1 palette can also be straightforwardly changed by the user\n\
6233  with plscmap1 or plscmap1l.\n\
6234 ";
6235 static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
6236 Set orientation\n\
6237 \n\
6238 DESCRIPTION:\n\
6239 \n\
6240  Set integer plot orientation parameter. This function is identical to\n\
6241  plsdiori except for the type of the argument, and should be used in\n\
6242  the same way. See the documentation of plsdiori for details.\n\
6243 \n\
6244  Redacted form: plsori(ori)\n\
6245 \n\
6246  This function is used in example 3.\n\
6247 \n\
6248 \n\
6249 \n\
6250 SYNOPSIS:\n\
6251 \n\
6252 plsori(ori)\n\
6253 \n\
6254 ARGUMENTS:\n\
6255 \n\
6256  ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
6257  portrait, etc.) The value is multiplied by 90 degrees to get the\n\
6258  angle.\n\
6259 ";
6260 static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6261 Calculate continuous time from broken-down time for the current stream\n\
6262 \n\
6263 DESCRIPTION:\n\
6264 \n\
6265  Calculate continuous time, ctime, from broken-down time for the\n\
6266  current stream. The broken-down\n\
6267  time is specified by the following parameters: year, month, day, hour,\n\
6268  min, and sec. This function is the inverse of plbtime.\n\
6269 \n\
6270  The PLplot definition of broken-down time is a calendar time that\n\
6271  completely ignores all time zone offsets, i.e., it is the user\'s\n\
6272  responsibility to apply those offsets (if so desired) before using the\n\
6273  PLplot time API. By default broken-down time is defined using the\n\
6274  proleptic Gregorian calendar without the insertion of leap seconds and\n\
6275  continuous time is defined as the number of seconds since the Unix\n\
6276  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6277  broken-down and continuous time are possible, see plconfigtime which\n\
6278  specifies that transformation for the current stream.\n\
6279 \n\
6280  Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6281  ctime)\n\
6282 \n\
6283 \n\
6284  This function is used in example 29.\n\
6285 \n\
6286 \n\
6287 \n\
6288 SYNOPSIS:\n\
6289 \n\
6290 plctime(year, month, day, hour, min, sec, ctime)\n\
6291 \n\
6292 ARGUMENTS:\n\
6293 \n\
6294  year (PLINT, input) : Input year.\n\
6295 \n\
6296  month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6297  (December).\n\
6298 \n\
6299  day (PLINT, input) : Input day in range from 1 to 31.\n\
6300 \n\
6301  hour (PLINT, input) : Input hour in range from 0 to 23\n\
6302 \n\
6303  min (PLINT, input) : Input minute in range from 0 to 59.\n\
6304 \n\
6305  sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6306 \n\
6307  ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6308  time calculated from the broken-down time specified by the\n\
6309  previous parameters.\n\
6310 ";
6311 static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
6312 Plot continental outline or shapefile data in world coordinates\n\
6313 \n\
6314 DESCRIPTION:\n\
6315 \n\
6316  Plots continental outlines or shapefile data in world coordinates. A\n\
6317  demonstration of how to use this function to create different\n\
6318  projections can be found in examples/c/x19c. PLplot is provided with\n\
6319  basic coastal outlines and USA state borders. To use the map\n\
6320  functionality PLplot must be compiled with the shapelib library.\n\
6321  Shapefiles have become a popular standard for geographical data and\n\
6322  data in this format can be easily found from a number of online\n\
6323  sources. Shapefile data is actually provided as three or more files\n\
6324  with the same filename, but different extensions. The .shp and .shx\n\
6325  files are required for plotting Shapefile data with PLplot.\n\
6326 \n\
6327  PLplot currently supports the point, multipoint, polyline and polygon\n\
6328  objects within shapefiles. However holes in polygons are not\n\
6329  supported. When plmap is used the type of object is derived from the\n\
6330  shapefile, if you wish to override the type then use one of the other\n\
6331  plmap variants. The built in maps have line data only.\n\
6332 \n\
6333  Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
6334 \n\
6335  This function is used in example 19.\n\
6336 \n\
6337 \n\
6338 \n\
6339 SYNOPSIS:\n\
6340 \n\
6341 plmap(mapform, name, minx, maxx, miny, maxy)\n\
6342 \n\
6343 ARGUMENTS:\n\
6344 \n\
6345  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6346  transform the original map data coordinates to a new coordinate\n\
6347  system. The PLplot-supplied map data is provided as latitudes and\n\
6348  longitudes; other Shapefile data may be provided in other\n\
6349  coordinate systems as can be found in their .prj plain text files.\n\
6350  For example, by using this transform we can change from a\n\
6351  longitude, latitude coordinate to a polar stereographic\n\
6352  projection. Initially, x[0]..[n-1] are the original x coordinates\n\
6353  (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
6354  corresponding y coordinates (latitudes for the PLplot supplied\n\
6355  data). After the call to mapform(), x[] and y[] should be\n\
6356  replaced by the corresponding plot coordinates. If no transform is\n\
6357  desired, mapform can be replaced by NULL.\n\
6358 \n\
6359  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6360  the type of map plotted. This is either one of the PLplot built-in\n\
6361  maps or the file name of a set of Shapefile files without the file\n\
6362  extensions. For the PLplot built-in maps the possible values are:\n\
6363  \"globe\" -- continental outlines\n\
6364  \"usa\" -- USA and state boundaries\n\
6365  \"cglobe\" -- continental outlines and countries\n\
6366  \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6367 \n\
6368 \n\
6369  minx (PLFLT, input) : The minimum x value of map elements to be\n\
6370  drawn. The units must match the shapefile (built in maps are\n\
6371  degrees lat/lon). Objects in the file which do not encroach on the\n\
6372  box defined by minx, maxx, miny, maxy will not be rendered. But\n\
6373  note this is simply an optimisation, not a clipping so for objects\n\
6374  with some points inside the box and some points outside the box\n\
6375  all the points will be rendered. These parameters also define\n\
6376  latitude and longitude wrapping for shapefiles using these units.\n\
6377  Longitude points will be wrapped by integer multiples of 360\n\
6378  degrees to place them in the box. This allows the same data to be\n\
6379  used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
6380  you plot from -180-540 you will get two cycles of data drawn. The\n\
6381  value of minx must be less than the value of maxx. Passing in a\n\
6382  nan, max/-max floating point number or +/-infinity will case the\n\
6383  bounding box from the shapefile to be used.\n\
6384 \n\
6385  maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6386  drawn - see minx.\n\
6387 \n\
6388  miny (PLFLT, input) : The minimum y value of map elements to be\n\
6389  drawn - see minx.\n\
6390 \n\
6391  maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6392  drawn - see minx.\n\
6393 ";
6394 static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
6395 Calculate broken-down time from continuous time for the current stream\n\
6396 \n\
6397 DESCRIPTION:\n\
6398 \n\
6399  Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6400  continuous time, ctime for the current stream. This function is the\n\
6401  inverse of plctime.\n\
6402 \n\
6403  The PLplot definition of broken-down time is a calendar time that\n\
6404  completely ignores all time zone offsets, i.e., it is the user\'s\n\
6405  responsibility to apply those offsets (if so desired) before using the\n\
6406  PLplot time API. By default broken-down time is defined using the\n\
6407  proleptic Gregorian calendar without the insertion of leap seconds and\n\
6408  continuous time is defined as the number of seconds since the Unix\n\
6409  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6410  broken-down and continuous time are possible, see plconfigtime.\n\
6411 \n\
6412  Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6413  ctime)\n\
6414 \n\
6415 \n\
6416  This function is used in example 29.\n\
6417 \n\
6418 \n\
6419 \n\
6420 SYNOPSIS:\n\
6421 \n\
6422 plbtime(year, month, day, hour, min, sec, ctime)\n\
6423 \n\
6424 ARGUMENTS:\n\
6425 \n\
6426  year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6427  positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6428  non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6429  BCE, etc.)\n\
6430 \n\
6431  month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6432  the year in the range from 0 (January) to 11 (December).\n\
6433 \n\
6434  day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6435  month in the range from 1 to 31.\n\
6436 \n\
6437  hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6438  day in the range from 0 to 23.\n\
6439 \n\
6440  min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6441  hour in the range from 0 to 59\n\
6442 \n\
6443  sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6444  minute in range from 0. to 60.\n\
6445 \n\
6446  ctime (PLFLT, input) : Continuous time from which the broken-down\n\
6447  time is calculated.\n\
6448 ";
6449 static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
6450 Get current stream number\n\
6451 \n\
6452 DESCRIPTION:\n\
6453 \n\
6454  Gets the number of the current output stream. See also plsstrm.\n\
6455 \n\
6456  Redacted form: plgstrm(p_strm)\n\
6457 \n\
6458  This function is used in example 1,20.\n\
6459 \n\
6460 \n\
6461 \n\
6462 SYNOPSIS:\n\
6463 \n\
6464 plgstrm(p_strm)\n\
6465 \n\
6466 ARGUMENTS:\n\
6467 \n\
6468  p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6469  stream value.\n\
6470 ";
6471 static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
6472 Draw a line in 3 space\n\
6473 \n\
6474 DESCRIPTION:\n\
6475 \n\
6476  Draws line in 3 space defined by n points in x, y, and z. You must\n\
6477  first set up the viewport, the 2d viewing window (in world\n\
6478  coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6479  more info.\n\
6480 \n\
6481  Redacted form: plline3(x, y, z)\n\
6482 \n\
6483  This function is used in example 18.\n\
6484 \n\
6485 \n\
6486 \n\
6487 SYNOPSIS:\n\
6488 \n\
6489 plline3(n, x, y, z)\n\
6490 \n\
6491 ARGUMENTS:\n\
6492 \n\
6493  n (PLINT, input) : Number of points defining line.\n\
6494 \n\
6495  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6496  points.\n\
6497 \n\
6498  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6499  points.\n\
6500 \n\
6501  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6502  points.\n\
6503 ";
6504 static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
6505 Load Hershey fonts\n\
6506 \n\
6507 DESCRIPTION:\n\
6508 \n\
6509  Loads the Hershey fonts used for text and symbols. This routine may\n\
6510  be called before or after initializing PLplot. If not explicitly\n\
6511  called before PLplot initialization, then by default that\n\
6512  initialization loads Hershey fonts with the extended character set.\n\
6513  This routine only has a practical effect for devices that still use\n\
6514  Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6515  system fonts instead of Hershey fonts).\n\
6516 \n\
6517  Redacted form: plfontld(fnt)\n\
6518 \n\
6519  This function is used in examples 1 and 7.\n\
6520 \n\
6521 \n\
6522 \n\
6523 SYNOPSIS:\n\
6524 \n\
6525 plfontld(fnt)\n\
6526 \n\
6527 ARGUMENTS:\n\
6528 \n\
6529  fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6530  A zero value specifies Hershey fonts with the standard character\n\
6531  set and a non-zero value (the default assumed if plfontld is never\n\
6532  called) specifies Hershey fonts with the extended character set.\n\
6533 ";
6534 static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
6535 Set any command-line option\n\
6536 \n\
6537 DESCRIPTION:\n\
6538 \n\
6539  Set any command-line option internally from a program before it\n\
6540  invokes plinit. opt is the name of the command-line option and optarg\n\
6541  is the corresponding command-line option argument.\n\
6542 \n\
6543  This function returns 0 on success.\n\
6544 \n\
6545  Redacted form: plsetopt(opt, optarg)\n\
6546 \n\
6547  This function is used in example 14.\n\
6548 \n\
6549 \n\
6550 \n\
6551 SYNOPSIS:\n\
6552 \n\
6553 PLINT plsetopt(opt, optarg)\n\
6554 \n\
6555 ARGUMENTS:\n\
6556 \n\
6557  opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6558  the command-line option.\n\
6559 \n\
6560  optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6561  containing the argument of the command-line option.\n\
6562 ";
6563 static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
6564 Plot all or a subset of Shapefile data using lines in world coordinates\n\
6565 \n\
6566 DESCRIPTION:\n\
6567 \n\
6568  Plot all or a subset of Shapefile data using lines in world\n\
6569  coordinates. Our 19th standard example demonstrates how to use this\n\
6570  function. This function plots data from a Shapefile using lines as in\n\
6571  plmap, however it also has the option of also only drawing specified\n\
6572  elements from the Shapefile. The vector of indices of the required\n\
6573  elements are passed as a function argument. The Shapefile data should\n\
6574  include a metadata file (extension.dbf) listing all items within the\n\
6575  Shapefile. This file can be opened by most popular spreadsheet\n\
6576  programs and can be used to decide which indices to pass to this\n\
6577  function.\n\
6578 \n\
6579  Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6580  plotentries)\n\
6581 \n\
6582  This function is used in example 19.\n\
6583 \n\
6584 \n\
6585 \n\
6586 SYNOPSIS:\n\
6587 \n\
6588 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6589 \n\
6590 ARGUMENTS:\n\
6591 \n\
6592  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6593  transform the coordinates given in the shapefile into a plot\n\
6594  coordinate system. By using this transform, we can change from a\n\
6595  longitude, latitude coordinate to a polar stereographic project,\n\
6596  for example. Initially, x[0]..[n-1] are the longitudes and\n\
6597  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6598  mapform(), x[] and y[] should be replaced by the corresponding\n\
6599  plot coordinates. If no transform is desired, mapform can be\n\
6600  replaced by NULL.\n\
6601 \n\
6602  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6603  the file name of a set of Shapefile files without the file\n\
6604  extension.\n\
6605 \n\
6606  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6607  be in the same units as used by the Shapefile. You could use a\n\
6608  very large negative number to plot everything, but you can improve\n\
6609  performance by limiting the area drawn. The units must match those\n\
6610  of the Shapefile projection, which may be for example longitude or\n\
6611  distance. The value of minx must be less than the value of maxx.\n\
6612 \n\
6613  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6614  use a very large number to plot everything, but you can improve\n\
6615  performance by limiting the area drawn.\n\
6616 \n\
6617  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6618  be in the same units as used by the Shapefile. You could use a\n\
6619  very large negative number to plot everything, but you can improve\n\
6620  performance by limiting the area drawn. The units must match those\n\
6621  of the Shapefile projection, which may be for example latitude or\n\
6622  distance. The value of miny must be less than the value of maxy.\n\
6623 \n\
6624  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6625  use a very large number to plot everything, but you can improve\n\
6626  performance by limiting the area drawn.\n\
6627 \n\
6628  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6629  zero-based indices of the Shapefile elements which will be drawn.\n\
6630  Setting\n\
6631  plotentries to NULL will plot all elements of the Shapefile.\n\
6632 \n\
6633  nplotentries (PLINT, input) : The number of items in\n\
6634  plotentries. Ignored if\n\
6635  plotentries is NULL.\n\
6636 ";
6637 static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6638 Used to globally turn color output on/off\n\
6639 \n\
6640 DESCRIPTION:\n\
6641 \n\
6642  Used to globally turn color output on/off for those drivers/devices\n\
6643  that support it.\n\
6644 \n\
6645  Redacted form: plscolor(color)\n\
6646 \n\
6647  This function is used in example 31.\n\
6648 \n\
6649 \n\
6650 \n\
6651 SYNOPSIS:\n\
6652 \n\
6653 plscolor(color)\n\
6654 \n\
6655 ARGUMENTS:\n\
6656 \n\
6657  color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6658  turned off. If non-zero, color is turned on.\n\
6659 ";
6660 static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
6661 Wait for graphics input event and translate to world coordinates.\n\
6662 \n\
6663 DESCRIPTION:\n\
6664 \n\
6665  Wait for graphics input event and translate to world coordinates.\n\
6666  Returns 0 if no translation to world coordinates is possible.\n\
6667 \n\
6668  This function returns 1 on success and 0 if no translation to world\n\
6669  coordinates is possible.\n\
6670 \n\
6671  Redacted form: plGetCursor(gin)\n\
6672 \n\
6673  This function is used in examples 1 and 20.\n\
6674 \n\
6675 \n\
6676 \n\
6677 SYNOPSIS:\n\
6678 \n\
6679 PLINT plGetCursor(gin)\n\
6680 \n\
6681 ARGUMENTS:\n\
6682 \n\
6683  gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6684  which will contain the output. The structure is not allocated by\n\
6685  the routine and must exist before the function is called.\n\
6686 ";
6687 static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
6688 Get the current device (keyword) name\n\
6689 \n\
6690 DESCRIPTION:\n\
6691 \n\
6692  Get the current device (keyword) name. Note: you must have allocated\n\
6693  space for this (80 characters is safe).\n\
6694 \n\
6695  Redacted form: plgdev(p_dev)\n\
6696 \n\
6697  This function is used in example 14.\n\
6698 \n\
6699 \n\
6700 \n\
6701 SYNOPSIS:\n\
6702 \n\
6703 plgdev(p_dev)\n\
6704 \n\
6705 ARGUMENTS:\n\
6706 \n\
6707  p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6708  (with preallocated length of 80 characters or more) containing the\n\
6709  device (keyword) name.\n\
6710 ";
6711 static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
6712 Add a point to a strip chart\n\
6713 \n\
6714 DESCRIPTION:\n\
6715 \n\
6716  Add a point to a given pen of a given strip chart. There is no need\n\
6717  for all pens to have the same number of points or to be equally\n\
6718  sampled in the x coordinate. Allocates memory and rescales as\n\
6719  necessary.\n\
6720 \n\
6721  Redacted form: plstripa(id, pen, x, y)\n\
6722 \n\
6723  This function is used in example 17.\n\
6724 \n\
6725 \n\
6726 \n\
6727 SYNOPSIS:\n\
6728 \n\
6729 plstripa(id, pen, x, y)\n\
6730 \n\
6731 ARGUMENTS:\n\
6732 \n\
6733  id (PLINT, input) : Identification number of the strip chart (set\n\
6734  up in plstripc).\n\
6735 \n\
6736  pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6737 \n\
6738  x (PLFLT, input) : X coordinate of point to plot.\n\
6739 \n\
6740  y (PLFLT, input) : Y coordinate of point to plot.\n\
6741 ";
6742 static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
6743 Create a 4-pen strip chart\n\
6744 \n\
6745 DESCRIPTION:\n\
6746 \n\
6747  Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6748 \n\
6749  Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6750  ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6751  styline, legline, labx, laby, labz)\n\
6752 \n\
6753 \n\
6754  This function is used in example 17.\n\
6755 \n\
6756 \n\
6757 \n\
6758 SYNOPSIS:\n\
6759 \n\
6760 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6761 \n\
6762 ARGUMENTS:\n\
6763 \n\
6764  id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6765  number of the strip chart to use on plstripa and plstripd.\n\
6766 \n\
6767  xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6768  the x-axis specification as in plbox.\n\
6769 \n\
6770  yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6771  the y-axis specification as in plbox.\n\
6772 \n\
6773  xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6774  change as data are added.\n\
6775 \n\
6776  xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6777  change as data are added.\n\
6778 \n\
6779  xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6780  is multiplied by the factor (1 +\n\
6781  xjump) .\n\
6782 \n\
6783  ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6784  change as data are added.\n\
6785 \n\
6786  ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6787  change as data are added.\n\
6788 \n\
6789  xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6790 \n\
6791  ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6792 \n\
6793  y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6794  true, otherwise not.\n\
6795 \n\
6796  acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6797  otherwise slide display.\n\
6798 \n\
6799  colbox (PLINT, input) : Plot box color index (cmap0).\n\
6800 \n\
6801  collab (PLINT, input) : Legend color index (cmap0).\n\
6802 \n\
6803  colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6804  indices for the 4 pens.\n\
6805 \n\
6806  styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6807  indices for the 4 pens.\n\
6808 \n\
6809  legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6810  strings containing legends for the 4 pens.\n\
6811 \n\
6812  labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6813  the label for the x axis.\n\
6814 \n\
6815  laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6816  the label for the y axis.\n\
6817 \n\
6818  labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6819  the plot title.\n\
6820 ";
6821 static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
6822 Deletes and releases memory used by a strip chart\n\
6823 \n\
6824 DESCRIPTION:\n\
6825 \n\
6826  Deletes and releases memory used by a strip chart.\n\
6827 \n\
6828  Redacted form: plstripd(id)\n\
6829 \n\
6830  This function is used in example 17.\n\
6831 \n\
6832 \n\
6833 \n\
6834 SYNOPSIS:\n\
6835 \n\
6836 plstripd(id)\n\
6837 \n\
6838 ARGUMENTS:\n\
6839 \n\
6840  id (PLINT, input) : Identification number of strip chart to delete.\n\
6841 ";
6842 static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
6843 Specify viewport using coordinates and aspect ratio\n\
6844 \n\
6845 DESCRIPTION:\n\
6846 \n\
6847  Device-independent routine for setting up the viewport. The viewport\n\
6848  is chosen to be the largest with the given aspect ratio that fits\n\
6849  within the specified region (in terms of normalized subpage\n\
6850  coordinates). This routine is functionally equivalent to plvpor when\n\
6851  a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6852  routine reserves no extra space at the edges for labels.\n\
6853 \n\
6854  Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6855 \n\
6856  This function is used in example 9.\n\
6857 \n\
6858 \n\
6859 \n\
6860 SYNOPSIS:\n\
6861 \n\
6862 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6863 \n\
6864 ARGUMENTS:\n\
6865 \n\
6866  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6867  left-hand edge of the viewport.\n\
6868 \n\
6869  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6870  right-hand edge of the viewport.\n\
6871 \n\
6872  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6873  bottom edge of the viewport.\n\
6874 \n\
6875  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6876  edge of the viewport.\n\
6877 \n\
6878  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6879  axis.\n\
6880 ";
6881 static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
6882 Assign a function to use for generating custom axis labels\n\
6883 \n\
6884 DESCRIPTION:\n\
6885 \n\
6886  This function allows a user to provide their own function to provide\n\
6887  axis label text. The user function is given the numeric value for a\n\
6888  point on an axis and returns a string label to correspond with that\n\
6889  value. Custom axis labels can be enabled by passing appropriate\n\
6890  arguments to plenv, plbox, plbox3 and similar functions.\n\
6891 \n\
6892  This function is used in example 19.\n\
6893 \n\
6894 \n\
6895 \n\
6896 SYNOPSIS:\n\
6897 \n\
6898 plslabelfunc(label_func, label_data)\n\
6899 \n\
6900 ARGUMENTS:\n\
6901 \n\
6902  label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6903  label function. In order to reset to the default labelling, set\n\
6904  this to NULL. The labelling function parameters are, in order:\n\
6905  axis: This indicates which axis a label is being requested for.\n\
6906  The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6907 \n\
6908  value: This is the value along the axis which is being labelled.\n\
6909 \n\
6910  label_text: The string representation of the label value.\n\
6911 \n\
6912  length: The maximum length in characters allowed for label_text.\n\
6913 \n\
6914 \n\
6915  label_data (PLPointer, input) : This parameter may be used to pass\n\
6916  data to the label_func function.\n\
6917 ";
6918 static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
6919 Set length of major ticks\n\
6920 \n\
6921 DESCRIPTION:\n\
6922 \n\
6923  This sets up the length of the major ticks. The actual length is the\n\
6924  product of the default length and a scaling factor as for character\n\
6925  height.\n\
6926 \n\
6927  Redacted form: plsmaj(def, scale)\n\
6928 \n\
6929  This function is used in example 29.\n\
6930 \n\
6931 \n\
6932 \n\
6933 SYNOPSIS:\n\
6934 \n\
6935 plsmaj(def, scale)\n\
6936 \n\
6937 ARGUMENTS:\n\
6938 \n\
6939  def (PLFLT, input) : The default length of a major tick in\n\
6940  millimeters, should be set to zero if the default length is to\n\
6941  remain unchanged.\n\
6942 \n\
6943  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6944  actual tick length.\n\
6945 ";
6946 static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
6947 Get the current library version number\n\
6948 \n\
6949 DESCRIPTION:\n\
6950 \n\
6951  Get the current library version number. Note: you must have allocated\n\
6952  space for this (80 characters is safe).\n\
6953 \n\
6954  Redacted form: plgver(p_ver)\n\
6955 \n\
6956  This function is used in example 1.\n\
6957 \n\
6958 \n\
6959 \n\
6960 SYNOPSIS:\n\
6961 \n\
6962 plgver(p_ver)\n\
6963 \n\
6964 ARGUMENTS:\n\
6965 \n\
6966  p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6967  (with preallocated length of 80 characters or more) containing the\n\
6968  PLplot version number.\n\
6969 ";
6970 static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
6971 Set format of numerical label for contours\n\
6972 \n\
6973 DESCRIPTION:\n\
6974 \n\
6975  Set format of numerical label for contours.\n\
6976 \n\
6977  Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
6978 \n\
6979  This function is used example 9.\n\
6980 \n\
6981 \n\
6982 \n\
6983 SYNOPSIS:\n\
6984 \n\
6985 pl_setcontlabelformat(lexp, sigdig)\n\
6986 \n\
6987 ARGUMENTS:\n\
6988 \n\
6989  lexp (PLINT, input) : If the contour numerical label is greater\n\
6990  than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
6991  format is used. Default value of lexp is 4.\n\
6992 \n\
6993  sigdig (PLINT, input) : Number of significant digits. Default\n\
6994  value is 2.\n\
6995 ";
6996 static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6997 Parse command-line arguments\n\
6998 \n\
6999 DESCRIPTION:\n\
7000 \n\
7001  Parse command-line arguments.\n\
7002 \n\
7003  plparseopts removes all recognized flags (decreasing argc\n\
7004  accordingly), so that invalid input may be readily detected. It can\n\
7005  also be used to process user command line flags. The user can merge\n\
7006  an option table of type PLOptionTable into the internal option table\n\
7007  info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7008  the external table(s) be parsed by calling plClearOpts before\n\
7009  plMergeOpts.\n\
7010 \n\
7011  The default action taken by plparseopts is as follows:\n\
7012  Returns with an error if an unrecognized option or badly formed\n\
7013  option-value pair are encountered.\n\
7014  Returns immediately (return code 0) when the first non-option command\n\
7015  line argument is found.\n\
7016  Returns with the return code of the option handler, if one was called.\n\
7017 \n\
7018  Deletes command line arguments from argv list as they are found, and\n\
7019  decrements argc accordingly.\n\
7020  Does not show \"invisible\" options in usage or help messages.\n\
7021  Assumes the program name is contained in argv[0].\n\
7022 \n\
7023  These behaviors may be controlled through the\n\
7024  mode argument.\n\
7025 \n\
7026  Redacted form: General: plparseopts(argv, mode)\n\
7027 \n\
7028 \n\
7029  This function is used in all of the examples.\n\
7030 \n\
7031 \n\
7032 \n\
7033 SYNOPSIS:\n\
7034 \n\
7035 PLINT plparseopts(p_argc, argv, mode)\n\
7036 \n\
7037 ARGUMENTS:\n\
7038 \n\
7039  p_argc (int *, input/output) : Number of arguments.\n\
7040 \n\
7041  argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7042  strings containing *p_argc command-line arguments.\n\
7043 \n\
7044  mode (PLINT, input) : Parsing mode with the following\n\
7045  possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7046  and all error messages enabled, including program exit when an\n\
7047  error occurs. Anything on the command line that isn\'t recognized\n\
7048  as a valid option or option argument is flagged as an error.\n\
7049  PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7050  of errors.\n\
7051  PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7052  arguments.\n\
7053  PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7054  PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7055  pointer to the program name.\n\
7056  PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7057  PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7058  unrecognized arguments.\n\
7059 ";
7060 static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
7061 Initialization\n\
7062 \n\
7063 DESCRIPTION:\n\
7064 \n\
7065  Initializing the plotting package. The program prompts for the device\n\
7066  keyword or number of the desired output device. Hitting a RETURN in\n\
7067  response to the prompt is the same as selecting the first device. If\n\
7068  only one device is enabled when PLplot is installed, plstar will issue\n\
7069  no prompt. The output device is divided into nx by ny subpages, each\n\
7070  of which may be used independently. The subroutine pladv is used to\n\
7071  advance from one subpage to the next.\n\
7072 \n\
7073  Redacted form: plstar(nx, ny)\n\
7074 \n\
7075  This function is used in example 1.\n\
7076 \n\
7077 \n\
7078 \n\
7079 SYNOPSIS:\n\
7080 \n\
7081 plstar(nx, ny)\n\
7082 \n\
7083 ARGUMENTS:\n\
7084 \n\
7085  nx (PLINT, input) : Number of subpages to divide output page in the\n\
7086  x direction.\n\
7087 \n\
7088  ny (PLINT, input) : Number of subpages to divide output page in the\n\
7089  y direction.\n\
7090 ";
7091 static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
7092 Get FCI (font characterization integer)\n\
7093 \n\
7094 DESCRIPTION:\n\
7095 \n\
7096  Gets information about the current font using the FCI approach. See\n\
7097  the PLplot documentation for more information.\n\
7098 \n\
7099  Redacted form: plgfci(p_fci)\n\
7100 \n\
7101  This function is used in example 23.\n\
7102 \n\
7103 \n\
7104 \n\
7105 SYNOPSIS:\n\
7106 \n\
7107 plgfci(p_fci)\n\
7108 \n\
7109 ARGUMENTS:\n\
7110 \n\
7111  p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
7112  FCI value.\n\
7113 ";
7114 static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
7115 Set family file parameters\n\
7116 \n\
7117 DESCRIPTION:\n\
7118 \n\
7119  Sets variables dealing with output file familying. Does nothing if\n\
7120  familying not supported by the driver. This routine, if used, must be\n\
7121  called before initializing PLplot. See the PLplot documentation for\n\
7122  more information.\n\
7123 \n\
7124  Redacted form: plsfam(fam, num, bmax)\n\
7125 \n\
7126  This function is used in examples 14 and 31.\n\
7127 \n\
7128 \n\
7129 \n\
7130 SYNOPSIS:\n\
7131 \n\
7132 plsfam(fam, num, bmax)\n\
7133 \n\
7134 ARGUMENTS:\n\
7135 \n\
7136  fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
7137  is enabled.\n\
7138 \n\
7139  num (PLINT, input) : Current family file number.\n\
7140 \n\
7141  bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
7142  file.\n\
7143 ";
7144 static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
7145 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
7146 \n\
7147 DESCRIPTION:\n\
7148 \n\
7149  This is a variant of plscmap1l that supports alpha channel\n\
7150  transparency. It sets cmap1 colors using a piece-wise linear\n\
7151  relationship between cmap1 intensity index (0.0-1.0) and position in\n\
7152  HLS or RGB color space (see the PLplot documentation) with alpha\n\
7153  transparency value (0.0-1.0). It may be called at any time.\n\
7154 \n\
7155  Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
7156  alpha, alt_hue_path)\n\
7157 \n\
7158  This function is used in example 30.\n\
7159 \n\
7160 \n\
7161 \n\
7162 SYNOPSIS:\n\
7163 \n\
7164 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
7165 \n\
7166 ARGUMENTS:\n\
7167 \n\
7168  itype (PLBOOL, input) : true: RGB, false: HLS.\n\
7169 \n\
7170  npts (PLINT, input) : number of control points.\n\
7171 \n\
7172  intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
7173  intensity index (0.0-1.0) in ascending order for each control\n\
7174  point.\n\
7175 \n\
7176  coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
7177  coordinate (H or R) for each control point.\n\
7178 \n\
7179  coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
7180  coordinate (L or G) for each control point.\n\
7181 \n\
7182  coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
7183  coordinate (S or B) for each control point.\n\
7184 \n\
7185  alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
7186  transparency value (0.0-1.0) for each control point.\n\
7187 \n\
7188  alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
7189  npts - 1 elements) containing the alternative interpolation method\n\
7190  Boolean value for each control point interval. (alt_hue_path[i]\n\
7191  refers to the interpolation interval between the i and i + 1\n\
7192  control points).\n\
7193 ";
7194 static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
7195 Set page parameters\n\
7196 \n\
7197 DESCRIPTION:\n\
7198 \n\
7199  Sets the page configuration (optional). If an individual parameter is\n\
7200  zero then that parameter value is not updated. Not all parameters are\n\
7201  recognized by all drivers and the interpretation is device-dependent.\n\
7202  The X-window driver uses the length and offset parameters to determine\n\
7203  the window size and location. The length and offset values are\n\
7204  expressed in units that are specific to the current driver. For\n\
7205  instance: screen drivers will usually interpret them as number of\n\
7206  pixels, whereas printer drivers will usually use mm.\n\
7207 \n\
7208  This routine, if used, must be called before initializing PLplot. It\n\
7209  may be called at later times for interactive drivers to change only\n\
7210  the dpi for subsequent redraws which you can force via a call to\n\
7211  plreplot. If this function is not called then the page size defaults\n\
7212  to landscape A4 for drivers which use real world page sizes and 744\n\
7213  pixels wide by 538 pixels high for raster drivers. The default value\n\
7214  for dx and dy is 90 pixels per inch for raster drivers.\n\
7215 \n\
7216 \n\
7217 \n\
7218  Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7219 \n\
7220  This function is used in examples 14 and 31.\n\
7221 \n\
7222 \n\
7223 \n\
7224 SYNOPSIS:\n\
7225 \n\
7226 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7227 \n\
7228 ARGUMENTS:\n\
7229 \n\
7230  xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
7231  by raster drivers, ignored by drivers which use \"real world\" units\n\
7232  (e.g. mm).\n\
7233 \n\
7234  yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
7235  by raster drivers, ignored by drivers which use \"real world\" units\n\
7236  (e.g. mm).\n\
7237 \n\
7238  xleng (PLINT, input) : Page length, x.\n\
7239 \n\
7240  yleng (PLINT, input) : Page length, y.\n\
7241 \n\
7242  xoff (PLINT, input) : Page offset, x.\n\
7243 \n\
7244  yoff (PLINT, input) : Page offset, y.\n\
7245 ";
7246 static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7247 Set precision in numeric labels\n\
7248 \n\
7249 DESCRIPTION:\n\
7250 \n\
7251  Sets the number of places after the decimal point in numeric labels.\n\
7252 \n\
7253  Redacted form: plprec(setp, prec)\n\
7254 \n\
7255  This function is used in example 29.\n\
7256 \n\
7257 \n\
7258 \n\
7259 SYNOPSIS:\n\
7260 \n\
7261 plprec(setp, prec)\n\
7262 \n\
7263 ARGUMENTS:\n\
7264 \n\
7265  setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7266  automatically determines the number of places to use after the\n\
7267  decimal point in numeric labels (like those used to label axes).\n\
7268  If setp is 1 then prec sets the number of places.\n\
7269 \n\
7270  prec (PLINT, input) : The number of characters to draw after the\n\
7271  decimal point in numeric labels.\n\
7272 ";
7273 static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
7274 Copy state parameters from the reference stream to the current stream\n\
7275 \n\
7276 DESCRIPTION:\n\
7277 \n\
7278  Copies state parameters from the reference stream to the current\n\
7279  stream. Tell driver interface to map device coordinates unless flags\n\
7280  == 1.\n\
7281 \n\
7282  This function is used for making save files of selected plots (e.g.\n\
7283  from the TK driver). After initializing, you can get a copy of the\n\
7284  current plot to the specified device by switching to this stream and\n\
7285  issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
7286  appropriate. The plot buffer must have previously been enabled (done\n\
7287  automatically by some display drivers, such as X).\n\
7288 \n\
7289  Redacted form: plcpstrm(iplsr, flags)\n\
7290 \n\
7291  This function is used in example 1,20.\n\
7292 \n\
7293 \n\
7294 \n\
7295 SYNOPSIS:\n\
7296 \n\
7297 plcpstrm(iplsr, flags)\n\
7298 \n\
7299 ARGUMENTS:\n\
7300 \n\
7301  iplsr (PLINT, input) : Number of reference stream.\n\
7302 \n\
7303  flags (PLBOOL, input) : If flags is set to true the device\n\
7304  coordinates are not copied from the reference to current stream.\n\
7305 ";
7306 static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
7307 Plot a glyph at the specified points\n\
7308 \n\
7309 DESCRIPTION:\n\
7310 \n\
7311  Plot a glyph at the specified points. (This function is largely\n\
7312  superseded by plstring which gives access to many[!] more glyphs.)\n\
7313  code=-1 means try to just draw a point. Right now it\'s just a move\n\
7314  and a draw at the same place. Not ideal, since a sufficiently\n\
7315  intelligent output device may optimize it away, or there may be faster\n\
7316  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7317  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7318  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7319  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7320  code <= 127 the corresponding printable ASCII character is plotted.\n\
7321 \n\
7322  Redacted form: plpoin(x, y, code)\n\
7323 \n\
7324  This function is used in examples 1, 6, 14, and 29.\n\
7325 \n\
7326 \n\
7327 \n\
7328 SYNOPSIS:\n\
7329 \n\
7330 plpoin(n, x, y, code)\n\
7331 \n\
7332 ARGUMENTS:\n\
7333 \n\
7334  n (PLINT, input) : Number of points in the x and y vectors.\n\
7335 \n\
7336  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7337  points.\n\
7338 \n\
7339  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7340  points.\n\
7341 \n\
7342  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7343  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7344  each of the n points.\n\
7345 ";
7346 static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
7347 Enter or leave xor mode\n\
7348 \n\
7349 DESCRIPTION:\n\
7350 \n\
7351  Enter (when mode is true) or leave (when mode is false) xor mode for\n\
7352  those drivers (e.g., the xwin driver) that support it. Enables\n\
7353  erasing plots by drawing twice the same line, symbol, etc. If driver\n\
7354  is not capable of xor operation it returns a status of false.\n\
7355 \n\
7356  Redacted form: plxormod(mode, status)\n\
7357 \n\
7358  This function is used in examples 1 and 20.\n\
7359 \n\
7360 \n\
7361 \n\
7362 SYNOPSIS:\n\
7363 \n\
7364 plxormod(mode, status)\n\
7365 \n\
7366 ARGUMENTS:\n\
7367 \n\
7368  mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7369  is false means leave xor mode.\n\
7370 \n\
7371  status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7372  modestatus of true (false) means driver is capable (incapable) of\n\
7373  xor mode.\n\
7374 ";
7375 static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
7376 Get viewport limits in normalized device coordinates\n\
7377 \n\
7378 DESCRIPTION:\n\
7379 \n\
7380  Get viewport limits in normalized device coordinates.\n\
7381 \n\
7382  Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7383 \n\
7384 \n\
7385  This function is used in example 31.\n\
7386 \n\
7387 \n\
7388 \n\
7389 SYNOPSIS:\n\
7390 \n\
7391 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7392 \n\
7393 ARGUMENTS:\n\
7394 \n\
7395  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7396  viewport limit of the normalized device coordinate in x.\n\
7397 \n\
7398  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7399  viewport limit of the normalized device coordinate in x.\n\
7400 \n\
7401  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7402  viewport limit of the normalized device coordinate in y.\n\
7403 \n\
7404  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7405  viewport limit of the normalized device coordinate in y.\n\
7406 ";
7407 static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
7408 Plot surface mesh\n\
7409 \n\
7410 DESCRIPTION:\n\
7411 \n\
7412  Plots a surface mesh within the environment set up by plw3d. The\n\
7413  surface is defined by the matrix z[\n\
7414  nx][\n\
7415  ny] , the point z[i][j] being the value of the function at (\n\
7416  x[i],\n\
7417  y[j]). Note that the points in vectors x and y do not need to be\n\
7418  equally spaced, but must be stored in ascending order. The parameter\n\
7419  opt controls the way in which the surface is displayed. For further\n\
7420  details see the PLplot documentation.\n\
7421 \n\
7422  Redacted form: plmesh(x, y, z, opt)\n\
7423 \n\
7424  This function is used in example 11.\n\
7425 \n\
7426 \n\
7427 \n\
7428 SYNOPSIS:\n\
7429 \n\
7430 plmesh(x, y, z, nx, ny, opt)\n\
7431 \n\
7432 ARGUMENTS:\n\
7433 \n\
7434  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7435  which the function is evaluated.\n\
7436 \n\
7437  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7438  which the function is evaluated.\n\
7439 \n\
7440  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7441  plot. Should have dimensions of\n\
7442  nx by\n\
7443  ny.\n\
7444 \n\
7445  nx (PLINT, input) : Number of x values at which function has been\n\
7446  evaluated.\n\
7447 \n\
7448  ny (PLINT, input) : Number of y values at which function has been\n\
7449  evaluated.\n\
7450 \n\
7451  opt (PLINT, input) : Determines the way in which the surface is\n\
7452  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7453  function of x for each value of y[j] .\n\
7454  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7455  for each value of x[i] .\n\
7456  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7457  at which function is defined.\n\
7458 ";
7459 static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
7460 Magnitude colored plot surface mesh with contour\n\
7461 \n\
7462 DESCRIPTION:\n\
7463 \n\
7464  A more powerful form of plmesh: the surface mesh can be colored\n\
7465  accordingly to the current z value being plotted, a contour plot can\n\
7466  be drawn at the base XY plane, and a curtain can be drawn between the\n\
7467  plotted function border and the base XY plane.\n\
7468 \n\
7469  Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7470 \n\
7471  This function is used in example 11.\n\
7472 \n\
7473 \n\
7474 \n\
7475 SYNOPSIS:\n\
7476 \n\
7477 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7478 \n\
7479 ARGUMENTS:\n\
7480 \n\
7481  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7482  which the function is evaluated.\n\
7483 \n\
7484  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7485  which the function is evaluated.\n\
7486 \n\
7487  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7488  plot. Should have dimensions of\n\
7489  nx by\n\
7490  ny.\n\
7491 \n\
7492  nx (PLINT, input) : Number of x values at which function is\n\
7493  evaluated.\n\
7494 \n\
7495  ny (PLINT, input) : Number of y values at which function is\n\
7496  evaluated.\n\
7497 \n\
7498  opt (PLINT, input) : Determines the way in which the surface is\n\
7499  represented. To specify more than one option just add the options,\n\
7500  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7501  showing z as a function of x for each value of y[j] .\n\
7502  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7503  for each value of x[i] .\n\
7504  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7505  at which function is defined.\n\
7506  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7507  the z value being plotted. The color is used from the current\n\
7508  cmap1.\n\
7509  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7510  using parameters\n\
7511  nlevel and\n\
7512  clevel.\n\
7513  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7514  the borders of the plotted function.\n\
7515 \n\
7516 \n\
7517  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7518  levels.\n\
7519 \n\
7520  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7521 ";
7522 static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
7523 End plotting session for current stream\n\
7524 \n\
7525 DESCRIPTION:\n\
7526 \n\
7527  Ends a plotting session for the current output stream only. See\n\
7528  plsstrm for more info.\n\
7529 \n\
7530  Redacted form: plend1()\n\
7531 \n\
7532  This function is used in examples 1 and 20.\n\
7533 \n\
7534 \n\
7535 \n\
7536 SYNOPSIS:\n\
7537 \n\
7538 plend1()\n\
7539 ";
7540 static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
7541 Get y axis parameters\n\
7542 \n\
7543 DESCRIPTION:\n\
7544 \n\
7545  Identical to plgxax, except that arguments are flags for y axis. See\n\
7546  the description of plgxax for more detail.\n\
7547 \n\
7548  Redacted form: plgyax(p_digmax, p_digits)\n\
7549 \n\
7550  This function is used in example 31.\n\
7551 \n\
7552 \n\
7553 \n\
7554 SYNOPSIS:\n\
7555 \n\
7556 plgyax(p_digmax, p_digits)\n\
7557 \n\
7558 ARGUMENTS:\n\
7559 \n\
7560  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7561  number of digits for the y axis. If nonzero, the printed label\n\
7562  has been switched to a floating-point representation when the\n\
7563  number of digits exceeds this value.\n\
7564 \n\
7565  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7566  number of digits for the numeric labels (y axis) from the last\n\
7567  plot.\n\
7568 ";
7569 static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
7570 Set plot orientation\n\
7571 \n\
7572 DESCRIPTION:\n\
7573 \n\
7574  Set plot orientation parameter which is multiplied by 90 degrees to\n\
7575  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7576  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7577  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7578  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7579  (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7580  not called the default value of rot is 0.\n\
7581 \n\
7582  N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7583  probably want to change the aspect ratio to a value suitable for the\n\
7584  plot orientation using a call to plsdidev or the command-line options\n\
7585  -a or -freeaspect. For more documentation of those options see the\n\
7586  PLplot documentation. Such command-line options can be set internally\n\
7587  using plsetopt or set directly using the command line and parsed using\n\
7588  a call to plparseopts.\n\
7589 \n\
7590  Redacted form: plsdiori(rot)\n\
7591 \n\
7592  This function is not used in any examples.\n\
7593 \n\
7594 \n\
7595 \n\
7596 SYNOPSIS:\n\
7597 \n\
7598 plsdiori(rot)\n\
7599 \n\
7600 ARGUMENTS:\n\
7601 \n\
7602  rot (PLFLT, input) : Plot orientation parameter.\n\
7603 ";
7604 static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7605 Plot a histogram from unbinned data\n\
7606 \n\
7607 DESCRIPTION:\n\
7608 \n\
7609  Plots a histogram from n data points stored in the data vector. This\n\
7610  routine bins the data into nbin bins equally spaced between datmin and\n\
7611  datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7612  opt allows, among other things, the histogram either to be plotted in\n\
7613  an existing window or causes plhist to call plenv with suitable limits\n\
7614  before plotting the histogram.\n\
7615 \n\
7616  Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7617 \n\
7618  This function is used in example 5.\n\
7619 \n\
7620 \n\
7621 \n\
7622 SYNOPSIS:\n\
7623 \n\
7624 plhist(n, data, datmin, datmax, nbin, opt)\n\
7625 \n\
7626 ARGUMENTS:\n\
7627 \n\
7628  n (PLINT, input) : Number of data points.\n\
7629 \n\
7630  data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7631  n data points.\n\
7632 \n\
7633  datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7634 \n\
7635  datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7636 \n\
7637  nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7638  divide the interval xmin to xmax.\n\
7639 \n\
7640  opt (PLINT, input) : Is a combination of several flags:\n\
7641  opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7642  the histogram data, the outer bins are expanded to fill up the\n\
7643  entire x-axis, data outside the given extremes are assigned to the\n\
7644  outer bins and bins of zero height are simply drawn.\n\
7645  opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7646  to fit the histogram data, without this flag, plenv is called\n\
7647  to set the world coordinates.\n\
7648  opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7649  extremes are not taken into account. This option should\n\
7650  probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7651  properly present the data.\n\
7652  opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7653  size as the ones inside.\n\
7654  opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7655  (there is a gap for such bins).\n\
7656 ";
7657 static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
7658 End plotting session\n\
7659 \n\
7660 DESCRIPTION:\n\
7661 \n\
7662  Ends a plotting session, tidies up all the output files, switches\n\
7663  interactive devices back into text mode and frees up any memory that\n\
7664  was allocated. Must be called before end of program.\n\
7665 \n\
7666  By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7667  wait state after a call to plend or other functions which trigger the\n\
7668  end of a plot page. To avoid this, use the plspause function.\n\
7669 \n\
7670  Redacted form: plend()\n\
7671 \n\
7672  This function is used in all of the examples.\n\
7673 \n\
7674 \n\
7675 \n\
7676 SYNOPSIS:\n\
7677 \n\
7678 plend()\n\
7679 ";
7680 static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
7681 Plot shaded 3-d surface plot\n\
7682 \n\
7683 DESCRIPTION:\n\
7684 \n\
7685  Plots a three-dimensional shaded surface plot within the environment\n\
7686  set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7687  z[\n\
7688  nx][\n\
7689  ny], the point z[i][j] being the value of the function at (\n\
7690  x[i],\n\
7691  y[j]). Note that the points in vectors x and y do not need to be\n\
7692  equally spaced, but must be stored in ascending order. For further\n\
7693  details see the PLplot documentation.\n\
7694 \n\
7695  Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7696 \n\
7697  This function is not used in any examples.\n\
7698 \n\
7699 \n\
7700 \n\
7701 SYNOPSIS:\n\
7702 \n\
7703 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7704 \n\
7705 ARGUMENTS:\n\
7706 \n\
7707  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7708  which the function is evaluated.\n\
7709 \n\
7710  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7711  which the function is evaluated.\n\
7712 \n\
7713  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7714  plot. Should have dimensions of\n\
7715  nx by\n\
7716  ny.\n\
7717 \n\
7718  nx (PLINT, input) : Number of x values at which function is\n\
7719  evaluated.\n\
7720 \n\
7721  ny (PLINT, input) : Number of y values at which function is\n\
7722  evaluated.\n\
7723 \n\
7724  opt (PLINT, input) : Determines the way in which the surface is\n\
7725  represented. To specify more than one option just add the options,\n\
7726  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7727  connecting points at which function is defined.\n\
7728  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7729  using parameters\n\
7730  nlevel and\n\
7731  clevel.\n\
7732  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7733  using parameters\n\
7734  nlevel and\n\
7735  clevel.\n\
7736  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7737  the borders of the plotted function.\n\
7738  opt=MAG_COLOR : the surface is colored according to the value\n\
7739  of Z; if MAG_COLOR is not used, then the surface is colored\n\
7740  according to the intensity of the reflected light in the\n\
7741  surface from a light source whose position is set using\n\
7742  pllightsource.\n\
7743 \n\
7744 \n\
7745  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7746  levels.\n\
7747 \n\
7748  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7749 ";
7750 static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
7751 Set device-compression level\n\
7752 \n\
7753 DESCRIPTION:\n\
7754 \n\
7755  Set device-compression level. Only used for drivers that provide\n\
7756  compression. This function, if used, should be invoked before a call\n\
7757  to plinit.\n\
7758 \n\
7759  Redacted form: plscompression(compression)\n\
7760 \n\
7761  This function is used in example 31.\n\
7762 \n\
7763 \n\
7764 \n\
7765 SYNOPSIS:\n\
7766 \n\
7767 plscompression(compression)\n\
7768 \n\
7769 ARGUMENTS:\n\
7770 \n\
7771  compression (PLINT, input) : The desired compression level. This is\n\
7772  a device-dependent value. Currently only the jpeg and png devices\n\
7773  use these values. For jpeg value is the jpeg quality which should\n\
7774  normally be in the range 0-95. Higher values denote higher quality\n\
7775  and hence larger image sizes. For png values are in the range -1\n\
7776  to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7777  A value of -1 denotes the default zlib compression level. Values\n\
7778  in the range 10-99 are divided by 10 and then used as the zlib\n\
7779  compression level. Higher compression levels correspond to greater\n\
7780  compression and small file sizes at the expense of more\n\
7781  computation.\n\
7782 ";
7783 static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
7784 Get the current device-compression setting\n\
7785 \n\
7786 DESCRIPTION:\n\
7787 \n\
7788  Get the current device-compression setting. This parameter is only\n\
7789  used for drivers that provide compression.\n\
7790 \n\
7791  Redacted form: plgcompression(compression)\n\
7792 \n\
7793  This function is used in example 31.\n\
7794 \n\
7795 \n\
7796 \n\
7797 SYNOPSIS:\n\
7798 \n\
7799 plgcompression(compression)\n\
7800 \n\
7801 ARGUMENTS:\n\
7802 \n\
7803  compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7804  compression setting for the current device.\n\
7805 ";
7806 static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
7807 Advance the (sub-)page\n\
7808 \n\
7809 DESCRIPTION:\n\
7810 \n\
7811  Advances to the next subpage if sub=0, performing a page advance if\n\
7812  there are no remaining subpages on the current page. If subpages\n\
7813  aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7814  PLplot switches to the specified subpage. Note that this allows you\n\
7815  to overwrite a plot on the specified subpage; if this is not what you\n\
7816  intended, use pleop followed by plbop to first advance the page. This\n\
7817  routine is called automatically (with page=0) by plenv, but if plenv\n\
7818  is not used, pladv must be called after initializing PLplot but before\n\
7819  defining the viewport.\n\
7820 \n\
7821  Redacted form: pladv(page)\n\
7822 \n\
7823  This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7824  29, and 31.\n\
7825 \n\
7826 \n\
7827 \n\
7828 SYNOPSIS:\n\
7829 \n\
7830 pladv(page)\n\
7831 \n\
7832 ARGUMENTS:\n\
7833 \n\
7834  page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7835  in the top left corner and increasing along the rows) to which to\n\
7836  advance. Set to zero to advance to the next subpage (or to the\n\
7837  next page if subpages are not being used).\n\
7838 ";
7839 static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7840 Set parameters of contour labelling other than format of numerical label\n\
7841 \n\
7842 DESCRIPTION:\n\
7843 \n\
7844  Set parameters of contour labelling other than those handled by\n\
7845  pl_setcontlabelformat.\n\
7846 \n\
7847  Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7848 \n\
7849  This function is used in example 9.\n\
7850 \n\
7851 \n\
7852 \n\
7853 SYNOPSIS:\n\
7854 \n\
7855 pl_setcontlabelparam(offset, size, spacing, active)\n\
7856 \n\
7857 ARGUMENTS:\n\
7858 \n\
7859  offset (PLFLT, input) : Offset of label from contour line (if set\n\
7860  to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7861 \n\
7862  size (PLFLT, input) : Font height for contour labels (normalized).\n\
7863  Default value is 0.3.\n\
7864 \n\
7865  spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7866  Default value is 0.1.\n\
7867 \n\
7868  active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7869  contour labels on. Default is off (0).\n\
7870 ";
7871 static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
7872 Set family, style and weight of the current font\n\
7873 \n\
7874 DESCRIPTION:\n\
7875 \n\
7876  Sets the current font. See the PLplot documentation for more\n\
7877  information on font selection.\n\
7878 \n\
7879  Redacted form: plsfont(family, style, weight)\n\
7880 \n\
7881  This function is used in example 23.\n\
7882 \n\
7883 \n\
7884 \n\
7885 SYNOPSIS:\n\
7886 \n\
7887 plsfont(family, style, weight)\n\
7888 \n\
7889 ARGUMENTS:\n\
7890 \n\
7891  family (PLINT, input) : Font family to select for the current font.\n\
7892  The available values are given by the PL_FCI_* constants in\n\
7893  plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7894  PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7895  signifies that the font family should not be altered.\n\
7896 \n\
7897  style (PLINT, input) : Font style to select for the current font.\n\
7898  The available values are given by the PL_FCI_* constants in\n\
7899  plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7900  PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7901  should not be altered.\n\
7902 \n\
7903  weight (PLINT, input) : Font weight to select for the current font.\n\
7904  The available values are given by the PL_FCI_* constants in\n\
7905  plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7906  negative value signifies that the font weight should not be\n\
7907  altered.\n\
7908 ";
7909 static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
7910 Sets the 3D position of the light source\n\
7911 \n\
7912 DESCRIPTION:\n\
7913 \n\
7914  Sets the 3D position of the light source for use with plsurf3d and\n\
7915  plsurf3dl\n\
7916 \n\
7917  Redacted form: pllightsource(x, y, z)\n\
7918 \n\
7919  This function is used in example 8.\n\
7920 \n\
7921 \n\
7922 \n\
7923 SYNOPSIS:\n\
7924 \n\
7925 pllightsource(x, y, z)\n\
7926 \n\
7927 ARGUMENTS:\n\
7928 \n\
7929  x (PLFLT, input) : X-coordinate of the light source.\n\
7930 \n\
7931  y (PLFLT, input) : Y-coordinate of the light source.\n\
7932 \n\
7933  z (PLFLT, input) : Z-coordinate of the light source.\n\
7934 ";
7935 static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
7936 Draw a line\n\
7937 \n\
7938 DESCRIPTION:\n\
7939 \n\
7940  Draws line defined by n points in x and y.\n\
7941 \n\
7942  Redacted form: plline(x, y)\n\
7943 \n\
7944  This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
7945  25-27, and 29.\n\
7946 \n\
7947 \n\
7948 \n\
7949 SYNOPSIS:\n\
7950 \n\
7951 plline(n, x, y)\n\
7952 \n\
7953 ARGUMENTS:\n\
7954 \n\
7955  n (PLINT, input) : Number of points defining line.\n\
7956 \n\
7957  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7958  points.\n\
7959 \n\
7960  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7961  points.\n\
7962 ";
7963 static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
7964 Set pen width\n\
7965 \n\
7966 DESCRIPTION:\n\
7967 \n\
7968  Sets the pen width.\n\
7969 \n\
7970  Redacted form: plwidth(width)\n\
7971 \n\
7972  This function is used in examples 1 and 2.\n\
7973 \n\
7974 \n\
7975 \n\
7976 SYNOPSIS:\n\
7977 \n\
7978 plwidth(width)\n\
7979 \n\
7980 ARGUMENTS:\n\
7981 \n\
7982  width (PLFLT, input) : The desired pen width. If width is negative\n\
7983  or the same as the previous value no action is taken. width = 0.\n\
7984  should be interpreted as as the minimum valid pen width for the\n\
7985  device. The interpretation of positive width values is also\n\
7986  device dependent.\n\
7987 ";
7988 static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
7989 Draw linear gradient inside polygon\n\
7990 \n\
7991 DESCRIPTION:\n\
7992 \n\
7993  Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
7994  points (\n\
7995  x[i],\n\
7996  y[i]). Interpretation of the polygon is the same as for plfill. The\n\
7997  polygon coordinates and the gradient angle are all expressed in world\n\
7998  coordinates. The angle from the x axis for both the rotated\n\
7999  coordinate system and the gradient vector is specified by angle. The\n\
8000  magnitude of the gradient vector is the difference between the maximum\n\
8001  and minimum values of x for the vertices in the rotated coordinate\n\
8002  system. The origin of the gradient vector can be interpreted as being\n\
8003  anywhere on the line corresponding to the minimum x value for the\n\
8004  vertices in the rotated coordinate system. The distance along the\n\
8005  gradient vector is linearly transformed to the independent variable of\n\
8006  color map 1 which ranges from 0. at the tail of the gradient vector to\n\
8007  1. at the head of the gradient vector. What is drawn is the RGBA\n\
8008  color corresponding to the independent variable of cmap1. For more\n\
8009  information about cmap1 (see the PLplot documentation).\n\
8010 \n\
8011  Redacted form: plgradient(x,y,angle)\n\
8012 \n\
8013  This function is used in examples 25 and 30.\n\
8014 \n\
8015 \n\
8016 \n\
8017 SYNOPSIS:\n\
8018 \n\
8019 plgradient(n, x, y, angle)\n\
8020 \n\
8021 ARGUMENTS:\n\
8022 \n\
8023  n (PLINT, input) : Number of vertices in polygon.\n\
8024 \n\
8025  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8026  vertices.\n\
8027 \n\
8028  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8029  vertices.\n\
8030 \n\
8031  angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
8032  axis.\n\
8033 ";
8034 static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
8035 Flushes the output stream\n\
8036 \n\
8037 DESCRIPTION:\n\
8038 \n\
8039  Flushes the output stream. Use sparingly, if at all.\n\
8040 \n\
8041  Redacted form: plflush()\n\
8042 \n\
8043  This function is used in examples 1 and 14.\n\
8044 \n\
8045 \n\
8046 \n\
8047 SYNOPSIS:\n\
8048 \n\
8049 plflush()\n\
8050 ";
8051 static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
8052 Get plot orientation\n\
8053 \n\
8054 DESCRIPTION:\n\
8055 \n\
8056  Get plot orientation parameter which is multiplied by 90 degrees to\n\
8057  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
8058  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
8059  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
8060  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
8061  (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
8062  not been called the default value pointed to by p_rot will be 0.\n\
8063 \n\
8064  Redacted form: plgdiori(p_rot)\n\
8065 \n\
8066  This function is not used in any examples.\n\
8067 \n\
8068 \n\
8069 \n\
8070 SYNOPSIS:\n\
8071 \n\
8072 plgdiori(p_rot)\n\
8073 \n\
8074 ARGUMENTS:\n\
8075 \n\
8076  p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
8077  parameter.\n\
8078 ";
8079 static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
8080 Set x axis parameters\n\
8081 \n\
8082 DESCRIPTION:\n\
8083 \n\
8084  Sets values of the digmax and digits flags for the x axis. See the\n\
8085  PLplot documentation for more information.\n\
8086 \n\
8087  Redacted form: plsxax(digmax, digits)\n\
8088 \n\
8089  This function is used in example 31.\n\
8090 \n\
8091 \n\
8092 \n\
8093 SYNOPSIS:\n\
8094 \n\
8095 plsxax(digmax, digits)\n\
8096 \n\
8097 ARGUMENTS:\n\
8098 \n\
8099  digmax (PLINT, input) : Variable to set the maximum number of\n\
8100  digits for the x axis. If nonzero, the printed label will be\n\
8101  switched to a floating-point representation when the number of\n\
8102  digits exceeds digmax.\n\
8103 \n\
8104  digits (PLINT, input) : Field digits value. Currently, changing\n\
8105  its value here has no effect since it is set only by plbox or\n\
8106  plbox3. However, the user may obtain its value after a call to\n\
8107  either of these functions by calling plgxax.\n\
8108 ";
8109 static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
8110 Get viewport limits in world coordinates\n\
8111 \n\
8112 DESCRIPTION:\n\
8113 \n\
8114  Get viewport limits in world coordinates.\n\
8115 \n\
8116  Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8117 \n\
8118 \n\
8119  This function is used in example 31.\n\
8120 \n\
8121 \n\
8122 \n\
8123 SYNOPSIS:\n\
8124 \n\
8125 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8126 \n\
8127 ARGUMENTS:\n\
8128 \n\
8129  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8130  viewport limit of the world coordinate in x.\n\
8131 \n\
8132  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8133  viewport limit of the world coordinate in x.\n\
8134 \n\
8135  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8136  viewport limit of the world coordinate in y.\n\
8137 \n\
8138  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8139  viewport limit of the world coordinate in y.\n\
8140 ";
8141 static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
8142 Shade regions on the basis of value\n\
8143 \n\
8144 DESCRIPTION:\n\
8145 \n\
8146  Shade regions on the basis of value. This is the high-level routine\n\
8147  for making continuous color shaded plots with cmap1 while plshade\n\
8148  should be used to plot individual shaded regions using either cmap0 or\n\
8149  cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
8150  our supported languages.\n\
8151 \n\
8152  Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
8153  clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
8154  pltr_data)\n\
8155 \n\
8156 \n\
8157  This function is used in examples 16, 21, and 22.\n\
8158 \n\
8159 \n\
8160 \n\
8161 SYNOPSIS:\n\
8162 \n\
8163 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
8164 \n\
8165 ARGUMENTS:\n\
8166 \n\
8167  a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8168  plot. Should have dimensions of\n\
8169  nx by\n\
8170  ny.\n\
8171 \n\
8172  nx (PLINT, input) : First dimension of matrix \"a\".\n\
8173 \n\
8174  ny (PLINT, input) : Second dimension of matrix \"a\".\n\
8175 \n\
8176  defined (PLDEFINED_callback, input) : Callback function specifying\n\
8177  the region that should be plotted in the shade plot. This\n\
8178  function accepts x and y coordinates as input arguments and must\n\
8179  return 1 if the point is to be included in the shade plot and 0\n\
8180  otherwise. If you want to plot the entire shade plot (the usual\n\
8181  case), this argument should be set to NULL.\n\
8182 \n\
8183  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8184  pltr below for how these arguments are used (only for the special case\n\
8185  when the callback function\n\
8186  pltr is not supplied).\n\
8187 \n\
8188  clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
8189  corresponding to the edges of each shaded region that will be\n\
8190  plotted by this function. To work properly the levels should be\n\
8191  monotonic.\n\
8192 \n\
8193  nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
8194  of shade edge values in clevel).\n\
8195 \n\
8196  fill_width (PLFLT, input) : Defines the line width used by the fill\n\
8197  pattern.\n\
8198 \n\
8199  cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
8200  contours defining edges of shaded regions. The pen color is only\n\
8201  temporary set for the contour drawing. Set this value to zero or\n\
8202  less if no shade edge contours are wanted.\n\
8203 \n\
8204  cont_width (PLFLT, input) : Defines line width used for contours\n\
8205  defining edges of shaded regions. This value may not be honored\n\
8206  by all drivers. The pen width is only temporary set for the\n\
8207  contour drawing. Set this value to zero or less if no shade edge\n\
8208  contours are wanted.\n\
8209 \n\
8210  fill (PLFILL_callback, input) : Callback routine used to fill the\n\
8211  region. Use plfill for this purpose.\n\
8212 \n\
8213  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8214  map to rectangles after coordinate transformation with pltrl.\n\
8215  Otherwise, set rectangular to false. If rectangular is set to\n\
8216  true, plshade tries to save time by filling large rectangles.\n\
8217  This optimization fails if the coordinate transformation distorts\n\
8218  the shape of rectangles. For example a plot in polar coordinates\n\
8219  has to have rectangular set to false.\n\
8220 \n\
8221  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8222  defines the transformation between the zero-based indices of the\n\
8223  matrix a and world coordinates. If\n\
8224  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8225  indices of a are mapped to the range\n\
8226  xmin through\n\
8227  xmax and the y indices of a are mapped to the range\n\
8228  ymin through\n\
8229  ymax.For the C case, transformation functions are provided in the\n\
8230  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8231  pltr2 for arbitrary mappings respectively defined by vectors and\n\
8232  matrices. In addition, C callback routines for the transformation\n\
8233  can be supplied by the user such as the mypltr function in\n\
8234  examples/c/x09c.c which provides a general linear transformation\n\
8235  between index coordinates and world coordinates.For languages\n\
8236  other than C you should consult the PLplot documentation for the\n\
8237  details concerning how PLTRANSFORM_callback arguments are\n\
8238  interfaced. However, in general, a particular pattern of\n\
8239  callback-associated arguments such as a tr vector with 6 elements;\n\
8240  xg and yg vectors; or xg and yg matrices are respectively\n\
8241  interfaced to a linear-transformation routine similar to the above\n\
8242  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8243  sophisticated bindings (see, e.g., the PLplot documentation)\n\
8244  support native language callbacks for handling index to\n\
8245  world-coordinate transformations. Examples of these various\n\
8246  approaches are given in examples/<language>x09*,\n\
8247  examples/<language>x16*, examples/<language>x20*,\n\
8248  examples/<language>x21*, and examples/<language>x22*, for all our\n\
8249  supported languages.\n\
8250 \n\
8251  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8252  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8253  externally supplied.\n\
8254 ";
8255 static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
8256 Plot color bar for image, shade or gradient plots\n\
8257 \n\
8258 DESCRIPTION:\n\
8259 \n\
8260  Routine for creating a continuous color bar for image, shade, or\n\
8261  gradient plots. (See pllegend for similar functionality for creating\n\
8262  legends with discrete elements). The arguments of plcolorbar provide\n\
8263  control over the location and size of the color bar as well as the\n\
8264  location and characteristics of the elements (most of which are\n\
8265  optional) within that color bar. The resulting color bar is clipped\n\
8266  at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
8267  system used for some of the parameters is defined in the documentation\n\
8268  of the position parameter.)\n\
8269 \n\
8270  Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
8271  position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
8272  low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
8273  labels, axis_opts, ticks, sub_ticks, values)\n\
8274 \n\
8275  This function is used in examples 16 and 33.\n\
8276 \n\
8277 \n\
8278 \n\
8279 SYNOPSIS:\n\
8280 \n\
8281 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\
8282 \n\
8283 ARGUMENTS:\n\
8284 \n\
8285  p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8286  labelled and decorated color bar width in adopted coordinates.\n\
8287 \n\
8288  p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8289  labelled and decorated color bar height in adopted coordinates.\n\
8290 \n\
8291  opt (PLINT, input) : opt contains bits controlling the overall\n\
8292  color bar. The orientation (direction of the maximum value) of\n\
8293  the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
8294  PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
8295  specified, the default orientation is toward the top if the\n\
8296  colorbar is placed on the left or right of the viewport or toward\n\
8297  the right if the colorbar is placed on the top or bottom of the\n\
8298  viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
8299  (semitransparent) background for the color bar. If the\n\
8300  PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8301  color bar. The type of color bar must be specified with one of\n\
8302  PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
8303  more than one of those bits is set only the first one in the above\n\
8304  list is honored. The position of the (optional) label/title can be\n\
8305  specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
8306  PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
8307  will be drawn. If more than one of this list of bits is specified,\n\
8308  only the first one on the list is honored. End-caps for the color\n\
8309  bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
8310  If a particular color bar cap option is not specified then no cap\n\
8311  will be drawn for that end. As a special case for\n\
8312  PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
8313  specified. If this option is provided then any tick marks and tick\n\
8314  labels will be placed at the breaks between shaded segments. TODO:\n\
8315  This should be expanded to support custom placement of tick marks\n\
8316  and tick labels at custom value locations for any color bar type.\n\
8317 \n\
8318  position (PLINT, input) : position contains bits which control the\n\
8319  overall position of the color bar and the definition of the\n\
8320  adopted coordinates used for positions just like what is done for\n\
8321  the position argument for pllegend. However, note that the\n\
8322  defaults for the position bits (see below) are different than the\n\
8323  pllegend case. The combination of the PL_POSITION_LEFT,\n\
8324  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8325  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8326  the 16 possible standard positions (the 4 corners and centers of\n\
8327  the 4 sides for both the inside and outside cases) of the color\n\
8328  bar relative to the adopted coordinate system. The corner\n\
8329  positions are specified by the appropriate combination of two of\n\
8330  the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8331  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8332  value of one of those bits. The adopted coordinates are\n\
8333  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8334  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8335  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8336  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8337  then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
8338  PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
8339  PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
8340  PL_POSITION_VIEWPORT.\n\
8341 \n\
8342  x (PLFLT, input) : X offset of the color bar position in adopted\n\
8343  coordinates from the specified standard position of the color bar.\n\
8344  For positive x, the direction of motion away from the standard\n\
8345  position is inward/outward from the standard corner positions or\n\
8346  standard left or right positions if the\n\
8347  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8348  For the standard top or bottom positions, the direction of motion\n\
8349  is toward positive X.\n\
8350 \n\
8351  y (PLFLT, input) : Y offset of the color bar position in adopted\n\
8352  coordinates from the specified standard position of the color bar.\n\
8353  For positive y, the direction of motion away from the standard\n\
8354  position is inward/outward from the standard corner positions or\n\
8355  standard top or bottom positions if the\n\
8356  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8357  For the standard left or right positions, the direction of motion\n\
8358  is toward positive Y.\n\
8359 \n\
8360  x_length (PLFLT, input) : Length of the body of the color bar in\n\
8361  the X direction in adopted coordinates.\n\
8362 \n\
8363  y_length (PLFLT, input) : Length of the body of the color bar in\n\
8364  the Y direction in adopted coordinates.\n\
8365 \n\
8366  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8367  color bar (PL_COLORBAR_BACKGROUND).\n\
8368 \n\
8369  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8370  for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8371 \n\
8372  bb_style (PLINT, input) : The pllsty style number for the\n\
8373  bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8374 \n\
8375  low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8376  bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8377 \n\
8378  high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8379  color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8380 \n\
8381  cont_color (PLINT, input) : The cmap0 contour color for\n\
8382  PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8383  it will be interpreted according to the design of plshades.\n\
8384 \n\
8385  cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8386  plots. This is passed directly to plshades, so it will be\n\
8387  interpreted according to the design of plshades.\n\
8388 \n\
8389  n_labels (PLINT, input) : Number of labels to place around the\n\
8390  color bar.\n\
8391 \n\
8392  label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8393  n_labels labels.\n\
8394 \n\
8395  labels (PLCHAR_MATRIX, input) : A vector of\n\
8396  n_labels UTF-8 character strings containing the labels for the color\n\
8397  bar. Ignored if no label position is specified with one of the\n\
8398  PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8399  PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8400  corresponding label_opts field.\n\
8401 \n\
8402  n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8403  value must be greater than 0. It is typically 1 (numerical axis\n\
8404  labels are provided for one of the long edges of the color bar),\n\
8405  but it can be larger if multiple numerical axis labels for the\n\
8406  long edges of the color bar are desired.\n\
8407 \n\
8408  axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8409  n_axes ascii character strings containing options (interpreted as for\n\
8410  plbox) for the color bar\'s axis definitions.\n\
8411 \n\
8412  ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8413  spacing of the major tick marks (interpreted as for plbox) for the\n\
8414  color bar\'s axis definitions.\n\
8415 \n\
8416  sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8417  number of subticks (interpreted as for plbox) for the color bar\'s\n\
8418  axis definitions.\n\
8419 \n\
8420  n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8421  elements in each of the n_axes rows of the values matrix.\n\
8422 \n\
8423  values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8424  values for the data range represented by the color bar. For a row\n\
8425  index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8426  elements in the row is specified by n_values[i_axis]. For\n\
8427  PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8428  is 2, and the corresponding row elements of the values matrix are\n\
8429  the minimum and maximum value represented by the colorbar. For\n\
8430  PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8431  of the values matrix is interpreted the same as the nlevel and\n\
8432  clevel arguments of plshades.\n\
8433 ";
8434 static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
8435 Get current subpage parameters\n\
8436 \n\
8437 DESCRIPTION:\n\
8438 \n\
8439  Gets the size of the current subpage in millimeters measured from the\n\
8440  bottom left hand corner of the output device page or screen. Can be\n\
8441  used in conjunction with plsvpa for setting the size of a viewport in\n\
8442  absolute coordinates (millimeters).\n\
8443 \n\
8444  Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8445 \n\
8446  This function is used in example 23.\n\
8447 \n\
8448 \n\
8449 \n\
8450 SYNOPSIS:\n\
8451 \n\
8452 plgspa(xmin, xmax, ymin, ymax)\n\
8453 \n\
8454 ARGUMENTS:\n\
8455 \n\
8456  xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8457  the left hand edge of the subpage in millimeters.\n\
8458 \n\
8459  xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8460  the right hand edge of the subpage in millimeters.\n\
8461 \n\
8462  ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8463  the bottom edge of the subpage in millimeters.\n\
8464 \n\
8465  ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8466  the top edge of the subpage in millimeters.\n\
8467 ";
8468 static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
8469 Shade individual region on the basis of value\n\
8470 \n\
8471 DESCRIPTION:\n\
8472 \n\
8473  Shade individual region on the basis of value. Use plshades if you\n\
8474  want to shade a number of contiguous regions using continuous colors.\n\
8475  In particular the edge contours are treated properly in plshades. If\n\
8476  you attempt to do contiguous regions with plshade the contours at the\n\
8477  edge of the shade are partially obliterated by subsequent plots of\n\
8478  contiguous shaded regions.\n\
8479 \n\
8480  Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8481  shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8482  min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8483 \n\
8484 \n\
8485  This function is used in example 15.\n\
8486 \n\
8487 \n\
8488 \n\
8489 SYNOPSIS:\n\
8490 \n\
8491 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\
8492 \n\
8493 ARGUMENTS:\n\
8494 \n\
8495  a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8496  plot. Should have dimensions of\n\
8497  nx by\n\
8498  ny.\n\
8499 \n\
8500  nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8501 \n\
8502  ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8503 \n\
8504  defined (PLDEFINED_callback, input) : Callback function specifying\n\
8505  the region that should be plotted in the shade plot. This\n\
8506  function accepts x and y coordinates as input arguments and must\n\
8507  return 1 if the point is to be included in the shade plot and 0\n\
8508  otherwise. If you want to plot the entire shade plot (the usual\n\
8509  case), this argument should be set to NULL.\n\
8510 \n\
8511  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8512  pltr below for how these arguments are used (only for the special case\n\
8513  when the callback function\n\
8514  pltr is not supplied).\n\
8515 \n\
8516  shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8517  be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8518 \n\
8519  shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8520  be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8521 \n\
8522  sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8523  sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8524  then sh_color is interpreted as a cmap1 argument in the range\n\
8525  (0.0-1.0).\n\
8526 \n\
8527  sh_color (PLFLT, input) : Defines color map index with integer\n\
8528  value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8529 \n\
8530  sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8531 \n\
8532  min_color (PLINT, input) : Defines pen color, width used by the\n\
8533  boundary of shaded region. The min values are used for the\n\
8534  shade_min boundary, and the max values are used on the shade_max\n\
8535  boundary. Set color and width to zero for no plotted boundaries.\n\
8536 \n\
8537  min_width (PLFLT, input) : Defines pen color, width used by the\n\
8538  boundary of shaded region. The min values are used for the\n\
8539  shade_min boundary, and the max values are used on the shade_max\n\
8540  boundary. Set color and width to zero for no plotted boundaries.\n\
8541 \n\
8542  max_color (PLINT, input) : Defines pen color, width used by the\n\
8543  boundary of shaded region. The min values are used for the\n\
8544  shade_min boundary, and the max values are used on the shade_max\n\
8545  boundary. Set color and width to zero for no plotted boundaries.\n\
8546 \n\
8547  max_width (PLFLT, input) : Defines pen color, width used by the\n\
8548  boundary of shaded region. The min values are used for the\n\
8549  shade_min boundary, and the max values are used on the shade_max\n\
8550  boundary. Set color and width to zero for no plotted boundaries.\n\
8551 \n\
8552  fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8553  Use plfill. Future version of PLplot may have other fill\n\
8554  routines.\n\
8555 \n\
8556  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8557  map to rectangles after coordinate transformation with pltrl.\n\
8558  Otherwise, set rectangular to false. If rectangular is set to\n\
8559  true, plshade tries to save time by filling large rectangles.\n\
8560  This optimization fails if the coordinate transformation distorts\n\
8561  the shape of rectangles. For example a plot in polar coordinates\n\
8562  has to have rectangular set to false.\n\
8563 \n\
8564  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8565  defines the transformation between the zero-based indices of the\n\
8566  matrix a and world coordinates. If\n\
8567  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8568  indices of a are mapped to the range\n\
8569  xmin through\n\
8570  xmax and the y indices of a are mapped to the range\n\
8571  ymin through\n\
8572  ymax.For the C case, transformation functions are provided in the\n\
8573  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8574  pltr2 for arbitrary mappings respectively defined by vectors and\n\
8575  matrices. In addition, C callback routines for the transformation\n\
8576  can be supplied by the user such as the mypltr function in\n\
8577  examples/c/x09c.c which provides a general linear transformation\n\
8578  between index coordinates and world coordinates.For languages\n\
8579  other than C you should consult the PLplot documentation for the\n\
8580  details concerning how PLTRANSFORM_callback arguments are\n\
8581  interfaced. However, in general, a particular pattern of\n\
8582  callback-associated arguments such as a tr vector with 6 elements;\n\
8583  xg and yg vectors; or xg and yg matrices are respectively\n\
8584  interfaced to a linear-transformation routine similar to the above\n\
8585  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8586  sophisticated bindings (see, e.g., the PLplot documentation)\n\
8587  support native language callbacks for handling index to\n\
8588  world-coordinate transformations. Examples of these various\n\
8589  approaches are given in examples/<language>x09*,\n\
8590  examples/<language>x16*, examples/<language>x20*,\n\
8591  examples/<language>x21*, and examples/<language>x22*, for all our\n\
8592  supported languages.\n\
8593 \n\
8594  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8595  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8596  externally supplied.\n\
8597 ";
8598 static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
8599 Calculate world coordinates and corresponding window index from relative device coordinates\n\
8600 \n\
8601 DESCRIPTION:\n\
8602 \n\
8603  Calculate world coordinates, wx and wy, and corresponding window index\n\
8604  from relative device coordinates, rx and ry.\n\
8605 \n\
8606  Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8607 \n\
8608 \n\
8609  This function is used in example 31.\n\
8610 \n\
8611 \n\
8612 \n\
8613 SYNOPSIS:\n\
8614 \n\
8615 plcalc_world(rx, ry, wx, wy, window)\n\
8616 \n\
8617 ARGUMENTS:\n\
8618 \n\
8619  rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8620  the x coordinate.\n\
8621 \n\
8622  ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8623  the y coordinate.\n\
8624 \n\
8625  wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8626  coordinate corresponding to the relative device coordinates rx and\n\
8627  ry.\n\
8628 \n\
8629  wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8630  coordinate corresponding to the relative device coordinates rx and\n\
8631  ry.\n\
8632 \n\
8633  window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8634  defined window index that corresponds to the input relative device\n\
8635  coordinates (and the returned world coordinates). To give some\n\
8636  background on the window index, for each page the initial window\n\
8637  index is set to zero, and each time plwind is called within the\n\
8638  page, world and device coordinates are stored for the window and\n\
8639  the window index is incremented. Thus, for a simple page layout\n\
8640  with non-overlapping viewports and one window per viewport, window\n\
8641  corresponds to the viewport index (in the order which the\n\
8642  viewport/windows were created) of the only viewport/window\n\
8643  corresponding to rx and ry. However, for more complicated layouts\n\
8644  with potentially overlapping viewports and possibly more than one\n\
8645  window (set of world coordinates) per viewport, window and the\n\
8646  corresponding output world coordinates corresponds to the last\n\
8647  window created that fulfills the criterion that the relative\n\
8648  device coordinates are inside it. Finally, in all cases where the\n\
8649  input relative device coordinates are not inside any\n\
8650  viewport/window, then the returned value of the last defined\n\
8651  window index is set to -1.\n\
8652 ";
8653 static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
8654 Draw a box with axes, etc, in 3-d\n\
8655 \n\
8656 DESCRIPTION:\n\
8657 \n\
8658  Draws axes, numeric and text labels for a three-dimensional surface\n\
8659  plot. For a more complete description of three-dimensional plotting\n\
8660  see the PLplot documentation.\n\
8661 \n\
8662  Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8663  ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8664 \n\
8665 \n\
8666  This function is used in examples 8, 11, 18, and 21.\n\
8667 \n\
8668 \n\
8669 \n\
8670 SYNOPSIS:\n\
8671 \n\
8672 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8673 \n\
8674 ARGUMENTS:\n\
8675 \n\
8676  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8677  options for the x axis. The string can include any combination of\n\
8678  the following letters (upper or lower case) in any order: b: Draws\n\
8679  axis at base, at height z=\n\
8680  zmin where zmin is defined by call to plw3d. This character must be\n\
8681  specified in order to use any of the other options.\n\
8682  d: Plot labels as date / time. Values are assumed to be\n\
8683  seconds since the epoch (as used by gmtime).\n\
8684  f: Always use fixed point numeric labels.\n\
8685  i: Inverts tick marks, so they are drawn downwards, rather\n\
8686  than upwards.\n\
8687  l: Labels axis logarithmically. This only affects the labels,\n\
8688  not the data, and so it is necessary to compute the logarithms\n\
8689  of data points before passing them to any of the drawing\n\
8690  routines.\n\
8691  n: Writes numeric labels at major tick intervals.\n\
8692  o: Use custom labelling function to generate axis label text.\n\
8693  The custom labelling function can be defined with the\n\
8694  plslabelfunc command.\n\
8695  s: Enables subticks between major ticks, only valid if t is\n\
8696  also specified.\n\
8697  t: Draws major ticks.\n\
8698  u: If this is specified, the text label for the axis is\n\
8699  written under the axis.\n\
8700 \n\
8701 \n\
8702  xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8703  the text label for the x axis. It is only drawn if u is in the\n\
8704  xopt string.\n\
8705 \n\
8706  xtick (PLFLT, input) : World coordinate interval between major\n\
8707  ticks on the x axis. If it is set to zero, PLplot automatically\n\
8708  generates a suitable tick interval.\n\
8709 \n\
8710  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8711  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8712  generates a suitable minor tick interval.\n\
8713 \n\
8714  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8715  options for the y axis. The string is interpreted in the same way\n\
8716  as xopt.\n\
8717 \n\
8718  ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8719  the text label for the y axis. It is only drawn if u is in the\n\
8720  yopt string.\n\
8721 \n\
8722  ytick (PLFLT, input) : World coordinate interval between major\n\
8723  ticks on the y axis. If it is set to zero, PLplot automatically\n\
8724  generates a suitable tick interval.\n\
8725 \n\
8726  nysub (PLINT, input) : Number of subintervals between major y axis\n\
8727  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8728  generates a suitable minor tick interval.\n\
8729 \n\
8730  zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8731  options for the z axis. The string can include any combination of\n\
8732  the following letters (upper or lower case) in any order: b: Draws\n\
8733  z axis to the left of the surface plot.\n\
8734  c: Draws z axis to the right of the surface plot.\n\
8735  d: Draws grid lines parallel to the x-y plane behind the\n\
8736  figure. These lines are not drawn until after plot3d or\n\
8737  plmesh are called because of the need for hidden line removal.\n\
8738  e: Plot labels as date / time. Values are assumed to be\n\
8739  seconds since the epoch (as used by gmtime). Note this\n\
8740  suboption is interpreted the same as the d suboption for xopt\n\
8741  and yopt, but it has to be identified as e for zopt since d\n\
8742  has already been used for the different purpose above.\n\
8743  f: Always use fixed point numeric labels.\n\
8744  i: Inverts tick marks, so they are drawn away from the center.\n\
8745  l: Labels axis logarithmically. This only affects the labels,\n\
8746  not the data, and so it is necessary to compute the logarithms\n\
8747  of data points before passing them to any of the drawing\n\
8748  routines.\n\
8749  m: Writes numeric labels at major tick intervals on the\n\
8750  right-hand z axis.\n\
8751  n: Writes numeric labels at major tick intervals on the\n\
8752  left-hand z axis.\n\
8753  o: Use custom labelling function to generate axis label text.\n\
8754  The custom labelling function can be defined with the\n\
8755  plslabelfunc command.\n\
8756  s: Enables subticks between major ticks, only valid if t is\n\
8757  also specified.\n\
8758  t: Draws major ticks.\n\
8759  u: If this is specified, the text label is written beside the\n\
8760  left-hand axis.\n\
8761  v: If this is specified, the text label is written beside the\n\
8762  right-hand axis.\n\
8763 \n\
8764 \n\
8765  zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8766  the text label for the z axis. It is only drawn if u or v are in\n\
8767  the zopt string.\n\
8768 \n\
8769  ztick (PLFLT, input) : World coordinate interval between major\n\
8770  ticks on the z axis. If it is set to zero, PLplot automatically\n\
8771  generates a suitable tick interval.\n\
8772 \n\
8773  nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8774  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8775  generates a suitable minor tick interval.\n\
8776 ";
8777 static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
8778 Get character default height and current (scaled) height\n\
8779 \n\
8780 DESCRIPTION:\n\
8781 \n\
8782  Get character default height and current (scaled) height.\n\
8783 \n\
8784  Redacted form: plgchr(p_def, p_ht)\n\
8785 \n\
8786  This function is used in example 23.\n\
8787 \n\
8788 \n\
8789 \n\
8790 SYNOPSIS:\n\
8791 \n\
8792 plgchr(p_def, p_ht)\n\
8793 \n\
8794 ARGUMENTS:\n\
8795 \n\
8796  p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8797  character height (mm).\n\
8798 \n\
8799  p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8800  character height (mm).\n\
8801 ";
8802 static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
8803 Set the escape character for text strings\n\
8804 \n\
8805 DESCRIPTION:\n\
8806 \n\
8807  Set the escape character for text strings. From C (in contrast to\n\
8808  Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
8809  characters are allowed to prevent the user from shooting himself in\n\
8810  the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
8811  use of backslash as a character escape). Here are the allowed escape\n\
8812  characters and their corresponding decimal ASCII values: !, ASCII 33\n\
8813  #, ASCII 35\n\
8814  $, ASCII 36\n\
8815  %, ASCII 37\n\
8816  &, ASCII 38\n\
8817  *, ASCII 42\n\
8818  @, ASCII 64\n\
8819  ^, ASCII 94\n\
8820  ~, ASCII 126\n\
8821 \n\
8822 \n\
8823  Redacted form: General: plsesc(esc)\n\
8824 \n\
8825 \n\
8826  This function is used in example 29.\n\
8827 \n\
8828 \n\
8829 \n\
8830 SYNOPSIS:\n\
8831 \n\
8832 plsesc(esc)\n\
8833 \n\
8834 ARGUMENTS:\n\
8835 \n\
8836  esc (char, input) : Escape character.\n\
8837 ";
8838 static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
8839 Draw a line between two points, accounting for coordinate transforms\n\
8840 \n\
8841 DESCRIPTION:\n\
8842 \n\
8843  Joins the point (\n\
8844  x1,\n\
8845  y1) to (\n\
8846  x2,\n\
8847  y2) . If a global coordinate transform is defined then the line is\n\
8848  broken in to n segments to approximate the path. If no transform is\n\
8849  defined then this simply acts like a call to pljoin.\n\
8850 \n\
8851  Redacted form: plpath(n,x1,y1,x2,y2)\n\
8852 \n\
8853  This function is used in example 22.\n\
8854 \n\
8855 \n\
8856 \n\
8857 SYNOPSIS:\n\
8858 \n\
8859 plpath(n, x1, y1, x2, y2)\n\
8860 \n\
8861 ARGUMENTS:\n\
8862 \n\
8863  n (PLINT, input) : number of points to use to approximate the path.\n\
8864 \n\
8865  x1 (PLFLT, input) : x coordinate of first point.\n\
8866 \n\
8867  y1 (PLFLT, input) : y coordinate of first point.\n\
8868 \n\
8869  x2 (PLFLT, input) : x coordinate of second point.\n\
8870 \n\
8871  y2 (PLFLT, input) : y coordinate of second point.\n\
8872 ";
8873 static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
8874 Set up standard window and draw box\n\
8875 \n\
8876 DESCRIPTION:\n\
8877 \n\
8878  Sets up plotter environment for simple graphs by calling pladv and\n\
8879  setting up viewport and window to sensible default values. plenv\n\
8880  leaves a standard margin (left-hand margin of eight character heights,\n\
8881  and a margin around the other three sides of five character heights)\n\
8882  around most graphs for axis labels and a title. When these defaults\n\
8883  are not suitable, use the individual routines plvpas, plvpor, or\n\
8884  plvasp for setting up the viewport, plwind for defining the window,\n\
8885  and plbox for drawing the box.\n\
8886 \n\
8887  Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8888 \n\
8889  This function is used in example 1,3,9,13,14,19-22,29.\n\
8890 \n\
8891 \n\
8892 \n\
8893 SYNOPSIS:\n\
8894 \n\
8895 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8896 \n\
8897 ARGUMENTS:\n\
8898 \n\
8899  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8900  world coordinates).\n\
8901 \n\
8902  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8903  world coordinates).\n\
8904 \n\
8905  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8906  coordinates).\n\
8907 \n\
8908  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8909  coordinates).\n\
8910 \n\
8911  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8912  scales will not be set, the user must set up the scale before\n\
8913  calling plenv using plsvpa, plvasp or other.\n\
8914  0: the x and y axes are scaled independently to use as much of\n\
8915  the screen as possible.\n\
8916  1: the scales of the x and y axes are made equal.\n\
8917  2: the axis of the x and y axes are made equal, and the plot\n\
8918  box will be square.\n\
8919 \n\
8920 \n\
8921  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8922  -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
8923  -1: draw box only.\n\
8924  0: draw box, ticks, and numeric tick labels.\n\
8925  1: also draw coordinate axes at x=0 and y=0.\n\
8926  2: also draw a grid at major tick positions in both\n\
8927  coordinates.\n\
8928  3: also draw a grid at minor tick positions in both\n\
8929  coordinates.\n\
8930  10: same as 0 except logarithmic x tick marks. (The x data\n\
8931  have to be converted to logarithms separately.)\n\
8932  11: same as 1 except logarithmic x tick marks. (The x data\n\
8933  have to be converted to logarithms separately.)\n\
8934  12: same as 2 except logarithmic x tick marks. (The x data\n\
8935  have to be converted to logarithms separately.)\n\
8936  13: same as 3 except logarithmic x tick marks. (The x data\n\
8937  have to be converted to logarithms separately.)\n\
8938  20: same as 0 except logarithmic y tick marks. (The y data\n\
8939  have to be converted to logarithms separately.)\n\
8940  21: same as 1 except logarithmic y tick marks. (The y data\n\
8941  have to be converted to logarithms separately.)\n\
8942  22: same as 2 except logarithmic y tick marks. (The y data\n\
8943  have to be converted to logarithms separately.)\n\
8944  23: same as 3 except logarithmic y tick marks. (The y data\n\
8945  have to be converted to logarithms separately.)\n\
8946  30: same as 0 except logarithmic x and y tick marks. (The x\n\
8947  and y data have to be converted to logarithms separately.)\n\
8948  31: same as 1 except logarithmic x and y tick marks. (The x\n\
8949  and y data have to be converted to logarithms separately.)\n\
8950  32: same as 2 except logarithmic x and y tick marks. (The x\n\
8951  and y data have to be converted to logarithms separately.)\n\
8952  33: same as 3 except logarithmic x and y tick marks. (The x\n\
8953  and y data have to be converted to logarithms separately.)\n\
8954  40: same as 0 except date / time x labels.\n\
8955  41: same as 1 except date / time x labels.\n\
8956  42: same as 2 except date / time x labels.\n\
8957  43: same as 3 except date / time x labels.\n\
8958  50: same as 0 except date / time y labels.\n\
8959  51: same as 1 except date / time y labels.\n\
8960  52: same as 2 except date / time y labels.\n\
8961  53: same as 3 except date / time y labels.\n\
8962  60: same as 0 except date / time x and y labels.\n\
8963  61: same as 1 except date / time x and y labels.\n\
8964  62: same as 2 except date / time x and y labels.\n\
8965  63: same as 3 except date / time x and y labels.\n\
8966  70: same as 0 except custom x and y labels.\n\
8967  71: same as 1 except custom x and y labels.\n\
8968  72: same as 2 except custom x and y labels.\n\
8969  73: same as 3 except custom x and y labels.\n\
8970 ";
8971 static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
8972 Grid data from irregularly sampled data\n\
8973 \n\
8974 DESCRIPTION:\n\
8975 \n\
8976  Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
8977  require data organized as a grid, i.e., with x sample point values\n\
8978  independent of y coordinate and vice versa. This function takes\n\
8979  irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
8980  vectors; reads the desired grid location from the input vectors\n\
8981  xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
8982  grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
8983  interpolate the data to the grid is specified with the argument type\n\
8984  which can have one parameter specified in argument data.\n\
8985 \n\
8986  Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8987  Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8988 \n\
8989 \n\
8990  This function is used in example 21.\n\
8991 \n\
8992 \n\
8993 \n\
8994 SYNOPSIS:\n\
8995 \n\
8996 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8997 \n\
8998 ARGUMENTS:\n\
8999 \n\
9000  x (PLFLT_VECTOR, input) : The input x vector.\n\
9001 \n\
9002  y (PLFLT_VECTOR, input) : The input y vector.\n\
9003 \n\
9004  z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
9005  y[i], z[i] represents one data sample coordinate.\n\
9006 \n\
9007  npts (PLINT, input) : The number of data samples in the x, y and z\n\
9008  vectors.\n\
9009 \n\
9010  xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
9011  in the x direction. Usually xg has nptsx equally spaced values\n\
9012  from the minimum to the maximum values of the x input vector.\n\
9013 \n\
9014  nptsx (PLINT, input) : The number of points in the xg vector.\n\
9015 \n\
9016  yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
9017  in the y direction. Similar to the xg parameter.\n\
9018 \n\
9019  nptsy (PLINT, input) : The number of points in the yg vector.\n\
9020 \n\
9021  zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
9022  where data lies in the grid specified by xg and yg. Therefore the\n\
9023  zg matrix must be dimensioned\n\
9024  nptsx by\n\
9025  nptsy.\n\
9026 \n\
9027  type (PLINT, input) : The type of grid interpolation algorithm to\n\
9028  use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
9029  GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
9030  GRID_NNI: Natural Neighbors Interpolation\n\
9031  GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
9032  GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
9033  GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
9034  Weighted\n\
9035  For details of the algorithms read the source file plgridd.c.\n\
9036 \n\
9037  data (PLFLT, input) : Some gridding algorithms require extra data,\n\
9038  which can be specified through this argument. Currently, for\n\
9039  algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
9040  use, the lower the value, the noisier (more local) the\n\
9041  approximation is.\n\
9042  GRID_NNLI, data specifies what a thin triangle is, in the\n\
9043  range [1. .. 2.]. High values enable the usage of very thin\n\
9044  triangles for interpolation, possibly resulting in error in\n\
9045  the approximation.\n\
9046  GRID_NNI, only weights greater than data will be accepted. If\n\
9047  0, all weights will be accepted.\n\
9048 ";
9049 static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
9050 Clear current (sub)page\n\
9051 \n\
9052 DESCRIPTION:\n\
9053 \n\
9054  Clears the current page, effectively erasing everything that have been\n\
9055  drawn. This command only works with interactive drivers; if the\n\
9056  driver does not support this, the page is filled with the background\n\
9057  color in use. If the current page is divided into subpages, only the\n\
9058  current subpage is erased. The nth subpage can be selected with\n\
9059  pladv(n).\n\
9060 \n\
9061  Redacted form: General: plclear()\n\
9062 \n\
9063 \n\
9064  This function is not used in any examples.\n\
9065 \n\
9066 \n\
9067 \n\
9068 SYNOPSIS:\n\
9069 \n\
9070 plclear()\n\
9071 ";
9072 static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
9073 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
9074 \n\
9075 DESCRIPTION:\n\
9076 \n\
9077  Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
9078  and PLFLT alpha transparency value. This sets the entire color map --\n\
9079  only as many colors as specified will be allocated.\n\
9080 \n\
9081  Redacted form: plscmap0a(r, g, b, alpha)\n\
9082 \n\
9083  This function is used in examples 30.\n\
9084 \n\
9085 \n\
9086 \n\
9087 SYNOPSIS:\n\
9088 \n\
9089 plscmap0a(r, g, b, alpha, ncol0)\n\
9090 \n\
9091 ARGUMENTS:\n\
9092 \n\
9093  r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9094  integers (0-255) representing the degree of red in the color.\n\
9095 \n\
9096  g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9097  integers (0-255) representing the degree of green in the color.\n\
9098 \n\
9099  b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9100  integers (0-255) representing the degree of blue in the color.\n\
9101 \n\
9102  alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
9103  representing the alpha transparency of the color.\n\
9104 \n\
9105  ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9106  vectors.\n\
9107 ";
9108 static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
9109 Set 8-bit RGB values for given cmap0 color index\n\
9110 \n\
9111 DESCRIPTION:\n\
9112 \n\
9113  Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
9114  index. Overwrites the previous color value for the given index and,\n\
9115  thus, does not result in any additional allocation of space for\n\
9116  colors.\n\
9117 \n\
9118  Redacted form: plscol0(icol0, r, g, b)\n\
9119 \n\
9120  This function is used in any example 31.\n\
9121 \n\
9122 \n\
9123 \n\
9124 SYNOPSIS:\n\
9125 \n\
9126 plscol0(icol0, r, g, b)\n\
9127 \n\
9128 ARGUMENTS:\n\
9129 \n\
9130  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
9131  number of colors (which is set by default, by plscmap0n, or even\n\
9132  by plscmap0).\n\
9133 \n\
9134  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9135  degree of red in the color.\n\
9136 \n\
9137  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9138  degree of green in the color.\n\
9139 \n\
9140  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9141  degree of blue in the color.\n\
9142 ";
9143 static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
9144 Set up transformation from metafile coordinates\n\
9145 \n\
9146 DESCRIPTION:\n\
9147 \n\
9148  Set up transformation from metafile coordinates. The size of the plot\n\
9149  is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
9150  general-purpose facility just yet (not sure why the user would need\n\
9151  it, for one).\n\
9152 \n\
9153  Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
9154  dimypmm)\n\
9155 \n\
9156  This function is not used in any examples.\n\
9157 \n\
9158 \n\
9159 \n\
9160 SYNOPSIS:\n\
9161 \n\
9162 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
9163 \n\
9164 ARGUMENTS:\n\
9165 \n\
9166  dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
9167 \n\
9168  dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
9169 \n\
9170  dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
9171 \n\
9172  dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
9173 \n\
9174  dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9175 \n\
9176  dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9177 ";
9178 static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
9179 Creates a new stream and makes it the default\n\
9180 \n\
9181 DESCRIPTION:\n\
9182 \n\
9183  Creates a new stream and makes it the default. Differs from using\n\
9184  plsstrm, in that a free stream number is found, and returned.\n\
9185  Unfortunately, I have to start at stream 1 and work upward, since\n\
9186  stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
9187  that no initial, library-opening call is required. So stream 0 must\n\
9188  be preallocated, and there is no simple way of determining whether it\n\
9189  is already in use or not.\n\
9190 \n\
9191  Redacted form: plmkstrm(p_strm)\n\
9192 \n\
9193  This function is used in examples 1 and 20.\n\
9194 \n\
9195 \n\
9196 \n\
9197 SYNOPSIS:\n\
9198 \n\
9199 plmkstrm(p_strm)\n\
9200 \n\
9201 ARGUMENTS:\n\
9202 \n\
9203  p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
9204  number of the created stream.\n\
9205 ";
9206 static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
9207 Get page parameters\n\
9208 \n\
9209 DESCRIPTION:\n\
9210 \n\
9211  Gets the current page configuration. The length and offset values are\n\
9212  expressed in units that are specific to the current driver. For\n\
9213  instance: screen drivers will usually interpret them as number of\n\
9214  pixels, whereas printer drivers will usually use mm.\n\
9215 \n\
9216  Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9217 \n\
9218  This function is used in examples 14 and 31.\n\
9219 \n\
9220 \n\
9221 \n\
9222 SYNOPSIS:\n\
9223 \n\
9224 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9225 \n\
9226 ARGUMENTS:\n\
9227 \n\
9228  p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9229  pixels/inch (DPI) in x.\n\
9230 \n\
9231  p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9232  pixels/inch (DPI) in y.\n\
9233 \n\
9234  p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9235  length.\n\
9236 \n\
9237  p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9238  length.\n\
9239 \n\
9240  p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9241  offset.\n\
9242 \n\
9243  p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9244  offset.\n\
9245 ";
9246 static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
9247 Set format for date / time labels\n\
9248 \n\
9249 DESCRIPTION:\n\
9250 \n\
9251  Sets the format for date / time labels. To enable date / time format\n\
9252  labels see the options to plbox, plbox3, and plenv.\n\
9253 \n\
9254  Redacted form: pltimefmt(fmt)\n\
9255 \n\
9256  This function is used in example 29.\n\
9257 \n\
9258 \n\
9259 \n\
9260 SYNOPSIS:\n\
9261 \n\
9262 pltimefmt(fmt)\n\
9263 \n\
9264 ARGUMENTS:\n\
9265 \n\
9266  fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
9267  interpreted similarly to the format specifier of typical system\n\
9268  strftime routines except that PLplot ignores locale and also\n\
9269  supplies some useful extensions in the context of plotting. All\n\
9270  text in the string is printed as-is other than conversion\n\
9271  specifications which take the form of a \'%\' character followed by\n\
9272  further conversion specification character. The conversion\n\
9273  specifications which are similar to those provided by system\n\
9274  strftime routines are the following: %a: The abbreviated (English)\n\
9275  weekday name.\n\
9276  %A: The full (English) weekday name.\n\
9277  %b: The abbreviated (English) month name.\n\
9278  %B: The full (English) month name.\n\
9279  %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
9280  %C: The century number (year/100) as a 2-digit integer.\n\
9281  %d: The day of the month as a decimal number (range 01 to 31).\n\
9282  %D: Equivalent to %m/%d/%y (non-ISO).\n\
9283  %e: Like %d, but a leading zero is replaced by a space.\n\
9284  %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
9285  %h: Equivalent to %b.\n\
9286  %H: The hour as a decimal number using a 24-hour clock (range\n\
9287  00 to 23).\n\
9288  %I: The hour as a decimal number using a 12-hour clock (range\n\
9289  01 to 12).\n\
9290  %j: The day of the year as a decimal number (range 001 to\n\
9291  366).\n\
9292  %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
9293  23); single digits are preceded by a blank. (See also %H.)\n\
9294  %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
9295  12); single digits are preceded by a blank. (See also %I.)\n\
9296  %m: The month as a decimal number (range 01 to 12).\n\
9297  %M: The minute as a decimal number (range 00 to 59).\n\
9298  %n: A newline character.\n\
9299  %p: Either \"AM\" or \"PM\" according to the given time value.\n\
9300  Noon is treated as \"PM\" and midnight as \"AM\".\n\
9301  %r: Equivalent to %I:%M:%S %p.\n\
9302  %R: The time in 24-hour notation (%H:%M). For a version\n\
9303  including the seconds, see %T below.\n\
9304  %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
9305  +0000 (UTC).\n\
9306  %S: The second as a decimal number (range 00 to 60). (The\n\
9307  range is up to 60 to allow for occasional leap seconds.)\n\
9308  %t: A tab character.\n\
9309  %T: The time in 24-hour notation (%H:%M:%S).\n\
9310  %u: The day of the week as a decimal, range 1 to 7, Monday\n\
9311  being 1. See also %w.\n\
9312  %U: The week number of the current year as a decimal number,\n\
9313  range 00 to 53, starting with the first Sunday as the first\n\
9314  day of week 01. See also %V and %W.\n\
9315  %v: Equivalent to %e-%b-%Y.\n\
9316  %V: The ISO 8601 week number of the current year as a decimal\n\
9317  number, range 01 to 53, where week 1 is the first week that\n\
9318  has at least 4 days in the new year. See also %U and %W.\n\
9319  %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
9320  being 0. See also %u.\n\
9321  %W: The week number of the current year as a decimal number,\n\
9322  range 00 to 53, starting with the first Monday as the first\n\
9323  day of week 01.\n\
9324  %x: Equivalent to %a %b %d %Y.\n\
9325  %X: Equivalent to %T.\n\
9326  %y: The year as a decimal number without a century (range 00\n\
9327  to 99).\n\
9328  %Y: The year as a decimal number including a century.\n\
9329  %z: The UTC time-zone string = \"+0000\".\n\
9330  %Z: The UTC time-zone abbreviation = \"UTC\".\n\
9331  %+: The UTC date and time in default format of the Unix date\n\
9332  command which is equivalent to %a %b %d %T %Z %Y.\n\
9333  %%: A literal \"%\" character.\n\
9334  The conversion specifications which are extensions to those normally\n\
9335  provided by system strftime routines are the following: %(0-9):\n\
9336  The fractional part of the seconds field (including leading\n\
9337  decimal point) to the specified accuracy. Thus %S%3 would give\n\
9338  seconds to millisecond accuracy (00.000).\n\
9339  %.: The fractional part of the seconds field (including\n\
9340  leading decimal point) to the maximum available accuracy. Thus\n\
9341  %S%. would give seconds with fractional part up to 9 decimal\n\
9342  places if available.\n\
9343 ";
9344 static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
9345 Specify viewport using aspect ratio only\n\
9346 \n\
9347 DESCRIPTION:\n\
9348 \n\
9349  Selects the largest viewport with the given aspect ratio within the\n\
9350  subpage that leaves a standard margin (left-hand margin of eight\n\
9351  character heights, and a margin around the other three sides of five\n\
9352  character heights).\n\
9353 \n\
9354  Redacted form: plvasp(aspect)\n\
9355 \n\
9356  This function is used in example 13.\n\
9357 \n\
9358 \n\
9359 \n\
9360 SYNOPSIS:\n\
9361 \n\
9362 plvasp(aspect)\n\
9363 \n\
9364 ARGUMENTS:\n\
9365 \n\
9366  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9367  axis of resulting viewport.\n\
9368 ";
9369 static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
9370 Set output file name\n\
9371 \n\
9372 DESCRIPTION:\n\
9373 \n\
9374  Sets the current output file name, if applicable. If the file name\n\
9375  has not been specified and is required by the driver, the user will be\n\
9376  prompted for it. If using the X-windows output driver, this sets the\n\
9377  display name. This routine, if used, must be called before\n\
9378  initializing PLplot.\n\
9379 \n\
9380  Redacted form: plsfnam(fnam)\n\
9381 \n\
9382  This function is used in examples 1 and 20.\n\
9383 \n\
9384 \n\
9385 \n\
9386 SYNOPSIS:\n\
9387 \n\
9388 plsfnam(fnam)\n\
9389 \n\
9390 ARGUMENTS:\n\
9391 \n\
9392  fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9393  the file name.\n\
9394 ";
9395 static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
9396 Vector plot\n\
9397 \n\
9398 DESCRIPTION:\n\
9399 \n\
9400  Draws a plot of vector data contained in the matrices (\n\
9401  u[\n\
9402  nx][\n\
9403  ny],\n\
9404  v[\n\
9405  nx][\n\
9406  ny]) . The scaling factor for the vectors is given by scale. A\n\
9407  transformation routine pointed to by pltr with a pointer pltr_data for\n\
9408  additional data required by the transformation routine to map indices\n\
9409  within the matrices to the world coordinates. The style of the vector\n\
9410  arrow may be set using plsvect.\n\
9411 \n\
9412  Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9413  discussion) the pltr, pltr_data callback arguments are sometimes\n\
9414  replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9415  with either one or two dimensions.\n\
9416 \n\
9417  This function is used in example 22.\n\
9418 \n\
9419 \n\
9420 \n\
9421 SYNOPSIS:\n\
9422 \n\
9423 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9424 \n\
9425 ARGUMENTS:\n\
9426 \n\
9427  u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9428  and y components of the vector data to be plotted.\n\
9429 \n\
9430  nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9431 \n\
9432  scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9433  the vectors for plotting. If scale = 0 then the scaling factor is\n\
9434  automatically calculated for the data. If scale < 0 then the\n\
9435  scaling factor is automatically calculated for the data and then\n\
9436  multiplied by -\n\
9437  scale. If scale > 0 then the scaling factor is set to scale.\n\
9438 \n\
9439  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9440  defines the transformation between the zero-based indices of the\n\
9441  matrices u and v and world coordinates.For the C case,\n\
9442  transformation functions are provided in the PLplot library: pltr0\n\
9443  for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9444  mappings respectively defined by vectors and matrices. In\n\
9445  addition, C callback routines for the transformation can be\n\
9446  supplied by the user such as the mypltr function in\n\
9447  examples/c/x09c.c which provides a general linear transformation\n\
9448  between index coordinates and world coordinates.For languages\n\
9449  other than C you should consult the PLplot documentation for the\n\
9450  details concerning how PLTRANSFORM_callback arguments are\n\
9451  interfaced. However, in general, a particular pattern of\n\
9452  callback-associated arguments such as a tr vector with 6 elements;\n\
9453  xg and yg vectors; or xg and yg matrices are respectively\n\
9454  interfaced to a linear-transformation routine similar to the above\n\
9455  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9456  sophisticated bindings (see, e.g., the PLplot documentation)\n\
9457  support native language callbacks for handling index to\n\
9458  world-coordinate transformations. Examples of these various\n\
9459  approaches are given in examples/<language>x09*,\n\
9460  examples/<language>x16*, examples/<language>x20*,\n\
9461  examples/<language>x21*, and examples/<language>x22*, for all our\n\
9462  supported languages.\n\
9463 \n\
9464  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9465  information to pltr0, pltr1, pltr2, or whatever callback routine\n\
9466  that is externally supplied.\n\
9467 ";
9468 static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
9469 Set parameters that define current plot-space window\n\
9470 \n\
9471 DESCRIPTION:\n\
9472 \n\
9473  Set relative minima and maxima that define the current plot-space\n\
9474  window. If plsdiplt is not called the default values of xmin, ymin,\n\
9475  xmax, and ymax are 0., 0., 1., and 1.\n\
9476 \n\
9477  Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9478 \n\
9479  This function is used in example 31.\n\
9480 \n\
9481 \n\
9482 \n\
9483 SYNOPSIS:\n\
9484 \n\
9485 plsdiplt(xmin, ymin, xmax, ymax)\n\
9486 \n\
9487 ARGUMENTS:\n\
9488 \n\
9489  xmin (PLFLT, input) : Relative minimum in x.\n\
9490 \n\
9491  ymin (PLFLT, input) : Relative minimum in y.\n\
9492 \n\
9493  xmax (PLFLT, input) : Relative maximum in x.\n\
9494 \n\
9495  ymax (PLFLT, input) : Relative maximum in y.\n\
9496 ";
9497 static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
9498 Select line style\n\
9499 \n\
9500 DESCRIPTION:\n\
9501 \n\
9502  This sets the line style according to one of eight predefined patterns\n\
9503  (also see plstyl).\n\
9504 \n\
9505  Redacted form: pllsty(lin)\n\
9506 \n\
9507  This function is used in examples 9, 12, 22, and 25.\n\
9508 \n\
9509 \n\
9510 \n\
9511 SYNOPSIS:\n\
9512 \n\
9513 pllsty(lin)\n\
9514 \n\
9515 ARGUMENTS:\n\
9516 \n\
9517  lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9518  a continuous line, line style 2 is a line with short dashes and\n\
9519  gaps, line style 3 is a line with long dashes and gaps, line style\n\
9520  4 has long dashes and short gaps and so on.\n\
9521 ";
9522 static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
9523 Plot a glyph at the specified points\n\
9524 \n\
9525 DESCRIPTION:\n\
9526 \n\
9527  Plot a glyph at the specified points. (This function is largely\n\
9528  superseded by plstring which gives access to many[!] more glyphs.)\n\
9529 \n\
9530  Redacted form: plsym(x, y, code)\n\
9531 \n\
9532  This function is used in example 7.\n\
9533 \n\
9534 \n\
9535 \n\
9536 SYNOPSIS:\n\
9537 \n\
9538 plsym(n, x, y, code)\n\
9539 \n\
9540 ARGUMENTS:\n\
9541 \n\
9542  n (PLINT, input) : Number of points in the x and y vectors.\n\
9543 \n\
9544  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9545  the points.\n\
9546 \n\
9547  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9548  the points.\n\
9549 \n\
9550  code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9551  to be plotted at each of the n points.\n\
9552 ";
9553 static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
9554 Set the device (keyword) name\n\
9555 \n\
9556 DESCRIPTION:\n\
9557 \n\
9558  Set the device (keyword) name.\n\
9559 \n\
9560  Redacted form: plsdev(devname)\n\
9561 \n\
9562  This function is used in examples 1, 14, and 20.\n\
9563 \n\
9564 \n\
9565 \n\
9566 SYNOPSIS:\n\
9567 \n\
9568 plsdev(devname)\n\
9569 \n\
9570 ARGUMENTS:\n\
9571 \n\
9572  devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9573  containing the device name keyword of the required output device.\n\
9574  If\n\
9575  devname is NULL or if the first character of the string is a ``?\'\',\n\
9576  the normal (prompted) start up is used.\n\
9577 ";
9578 static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
9579 Set the background color by 8-bit RGB value\n\
9580 \n\
9581 DESCRIPTION:\n\
9582 \n\
9583  Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9584  the PLplot documentation).\n\
9585 \n\
9586  Redacted form: plscolbg(r, g, b)\n\
9587 \n\
9588  This function is used in examples 15 and 31.\n\
9589 \n\
9590 \n\
9591 \n\
9592 SYNOPSIS:\n\
9593 \n\
9594 plscolbg(r, g, b)\n\
9595 \n\
9596 ARGUMENTS:\n\
9597 \n\
9598  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9599  degree of red in the color.\n\
9600 \n\
9601  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9602  degree of green in the color.\n\
9603 \n\
9604  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9605  degree of blue in the color.\n\
9606 ";
9607 static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
9608 Set parameters incrementally (zoom mode) that define current plot-space window\n\
9609 \n\
9610 DESCRIPTION:\n\
9611 \n\
9612  Set relative minima and maxima incrementally (zoom mode) that define\n\
9613  the current plot-space window. This function has the same effect as\n\
9614  plsdiplt if that function has not been previously called. Otherwise,\n\
9615  this function implements zoom mode using the transformation min_used =\n\
9616  old_min + old_length*min and max_used = old_min + old_length*max for\n\
9617  each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
9618  repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9619 \n\
9620  Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9621 \n\
9622  This function is used in example 31.\n\
9623 \n\
9624 \n\
9625 \n\
9626 SYNOPSIS:\n\
9627 \n\
9628 plsdiplz(xmin, ymin, xmax, ymax)\n\
9629 \n\
9630 ARGUMENTS:\n\
9631 \n\
9632  xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9633 \n\
9634  ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9635 \n\
9636  xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9637 \n\
9638  ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9639 ";
9640 static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
9641 Advance to the next family file on the next new page\n\
9642 \n\
9643 DESCRIPTION:\n\
9644 \n\
9645  Advance to the next family file on the next new page.\n\
9646 \n\
9647  Redacted form: plfamadv()\n\
9648 \n\
9649  This function is not used in any examples.\n\
9650 \n\
9651 \n\
9652 \n\
9653 SYNOPSIS:\n\
9654 \n\
9655 plfamadv()\n\
9656 ";
9657 static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9658 Set number of colors in cmap0\n\
9659 \n\
9660 DESCRIPTION:\n\
9661 \n\
9662  Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9663  (or reallocate) cmap0, and fill with default values for those colors\n\
9664  not previously allocated. The first 16 default colors are given in\n\
9665  the plcol0 documentation. For larger indices the default color is\n\
9666  red.\n\
9667 \n\
9668  The drivers are not guaranteed to support more than 16 colors.\n\
9669 \n\
9670  Redacted form: plscmap0n(ncol0)\n\
9671 \n\
9672  This function is used in examples 15, 16, and 24.\n\
9673 \n\
9674 \n\
9675 \n\
9676 SYNOPSIS:\n\
9677 \n\
9678 plscmap0n(ncol0)\n\
9679 \n\
9680 ARGUMENTS:\n\
9681 \n\
9682  ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9683  the cmap0 palette. If this number is zero or less, then the value\n\
9684  from the previous call to plscmap0n is used and if there is no\n\
9685  previous call, then a default value is used.\n\
9686 ";
9687 static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
9688 Plot latitude and longitude lines\n\
9689 \n\
9690 DESCRIPTION:\n\
9691 \n\
9692  Displays latitude and longitude on the current plot. The lines are\n\
9693  plotted in the current color and line style.\n\
9694 \n\
9695  Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9696  minlat, maxlat)\n\
9697 \n\
9698  This function is used in example 19.\n\
9699 \n\
9700 \n\
9701 \n\
9702 SYNOPSIS:\n\
9703 \n\
9704 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9705 \n\
9706 ARGUMENTS:\n\
9707 \n\
9708  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9709  transform the coordinate longitudes and latitudes to a plot\n\
9710  coordinate system. By using this transform, we can change from a\n\
9711  longitude, latitude coordinate to a polar stereographic project,\n\
9712  for example. Initially, x[0]..[n-1] are the longitudes and\n\
9713  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9714  mapform(), x[] and y[] should be replaced by the corresponding\n\
9715  plot coordinates. If no transform is desired, mapform can be\n\
9716  replaced by NULL.\n\
9717 \n\
9718  dlong (PLFLT, input) : The interval in degrees at which the\n\
9719  longitude lines are to be plotted.\n\
9720 \n\
9721  dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9722  lines are to be plotted.\n\
9723 \n\
9724  minlong (PLFLT, input) : The value of the longitude on the left\n\
9725  side of the plot. The value of minlong must be less than the value\n\
9726  of maxlong, and the quantity maxlong-minlong must be less than or\n\
9727  equal to 360.\n\
9728 \n\
9729  maxlong (PLFLT, input) : The value of the longitude on the right\n\
9730  side of the plot.\n\
9731 \n\
9732  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9733  background. One can always use -90.0 as the boundary outside the\n\
9734  plot window will be automatically eliminated. However, the\n\
9735  program will be faster if one can reduce the size of the\n\
9736  background plotted.\n\
9737 \n\
9738  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9739  background. One can always use 90.0 as the boundary outside the\n\
9740  plot window will be automatically eliminated.\n\
9741 ";
9742 static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9743 Convert RGB color to HLS\n\
9744 \n\
9745 DESCRIPTION:\n\
9746 \n\
9747  Convert RGB color coordinates to HLS\n\
9748 \n\
9749  Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9750 \n\
9751 \n\
9752  This function is used in example 2.\n\
9753 \n\
9754 \n\
9755 \n\
9756 SYNOPSIS:\n\
9757 \n\
9758 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9759 \n\
9760 ARGUMENTS:\n\
9761 \n\
9762  r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9763 \n\
9764  g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9765 \n\
9766  b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9767 \n\
9768  p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9769  degrees (0.0-360.0) on the color cylinder.\n\
9770 \n\
9771  p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9772  expressed as a fraction (0.0-1.0) of the axis of the color\n\
9773  cylinder.\n\
9774 \n\
9775  p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9776  expressed as a fraction (0.0-1.0) of the radius of the color\n\
9777  cylinder.\n\
9778 ";
9779 static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
9780 Plot a glyph at the specified 3D points\n\
9781 \n\
9782 DESCRIPTION:\n\
9783 \n\
9784  Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9785  many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9786  this function similar to what is done for plline3. The glyph is\n\
9787  specified with a PLplot user string. Note that the user string is not\n\
9788  actually limited to one glyph so it is possible (but not normally\n\
9789  useful) to plot more than one glyph at the specified points with this\n\
9790  function. As with plmtex and plptex, the user string can contain FCI\n\
9791  escapes to determine the font, UTF-8 code to determine the glyph or\n\
9792  else PLplot escapes for Hershey or unicode text to determine the\n\
9793  glyph.\n\
9794 \n\
9795  Redacted form: plstring3(x, y, z, string)\n\
9796 \n\
9797  This function is used in example 18.\n\
9798 \n\
9799 \n\
9800 \n\
9801 SYNOPSIS:\n\
9802 \n\
9803 plstring3(n, x, y, z, string)\n\
9804 \n\
9805 ARGUMENTS:\n\
9806 \n\
9807  n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9808 \n\
9809  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9810  the points.\n\
9811 \n\
9812  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9813  the points.\n\
9814 \n\
9815  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9816  the points.\n\
9817 \n\
9818  string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9819  the glyph(s) to be plotted at each of the n points. points.\n\
9820 ";
9821 static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
9822 Switch to text screen\n\
9823 \n\
9824 DESCRIPTION:\n\
9825 \n\
9826  Sets an interactive device to text mode, used in conjunction with\n\
9827  plgra to allow graphics and text to be interspersed. On a device\n\
9828  which supports separate text and graphics windows, this command causes\n\
9829  control to be switched to the text window. This can be useful for\n\
9830  printing diagnostic messages or getting user input, which would\n\
9831  otherwise interfere with the plots. The program must switch back to\n\
9832  the graphics window before issuing plot commands, as the text (or\n\
9833  console) device will probably become quite confused otherwise. If\n\
9834  already in text mode, this command is ignored. It is also ignored on\n\
9835  devices which only support a single window or use a different method\n\
9836  for shifting focus (see also plgra).\n\
9837 \n\
9838  Redacted form: pltext()\n\
9839 \n\
9840  This function is used in example 1.\n\
9841 \n\
9842 \n\
9843 \n\
9844 SYNOPSIS:\n\
9845 \n\
9846 pltext()\n\
9847 ";
9848 static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
9849 Get parameters that define current plot-space window\n\
9850 \n\
9851 DESCRIPTION:\n\
9852 \n\
9853  Get relative minima and maxima that define current plot-space window.\n\
9854  If plsdiplt has not been called the default values pointed to by\n\
9855  p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9856 \n\
9857  Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9858 \n\
9859  This function is used in example 31.\n\
9860 \n\
9861 \n\
9862 \n\
9863 SYNOPSIS:\n\
9864 \n\
9865 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9866 \n\
9867 ARGUMENTS:\n\
9868 \n\
9869  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9870  minimum in x.\n\
9871 \n\
9872  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9873  minimum in y.\n\
9874 \n\
9875  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9876  maximum in x.\n\
9877 \n\
9878  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9879  maximum in y.\n\
9880 ";
9881 static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
9882 Get the (current) run level\n\
9883 \n\
9884 DESCRIPTION:\n\
9885 \n\
9886  Get the (current) run level. Valid settings are: 0, uninitialized\n\
9887  1, initialized\n\
9888  2, viewport defined\n\
9889  3, world coordinates defined\n\
9890 \n\
9891 \n\
9892  Redacted form: plglevel(p_level)\n\
9893 \n\
9894  This function is used in example 31.\n\
9895 \n\
9896 \n\
9897 \n\
9898 SYNOPSIS:\n\
9899 \n\
9900 plglevel(p_level)\n\
9901 \n\
9902 ARGUMENTS:\n\
9903 \n\
9904  p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9905  level.\n\
9906 ";
9907 static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
9908 Plot a histogram from binned data\n\
9909 \n\
9910 DESCRIPTION:\n\
9911 \n\
9912  Plots a histogram consisting of nbin bins. The value associated with\n\
9913  the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9914  placed in y[i]. For proper operation, the values in x[i] must form a\n\
9915  strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9916  of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9917  placed midway between the values in the x vector. Also see plhist for\n\
9918  drawing histograms from unbinned data.\n\
9919 \n\
9920  Redacted form: General: plbin(x, y, opt)\n\
9921  Python: plbin(nbin, x, y, opt)\n\
9922 \n\
9923 \n\
9924  This function is not used in any examples.\n\
9925 \n\
9926 \n\
9927 \n\
9928 SYNOPSIS:\n\
9929 \n\
9930 plbin(nbin, x, y, opt)\n\
9931 \n\
9932 ARGUMENTS:\n\
9933 \n\
9934  nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9935  and y vectors.)\n\
9936 \n\
9937  x (PLFLT_VECTOR, input) : A vector containing values associated\n\
9938  with bins. These must form a strictly increasing sequence.\n\
9939 \n\
9940  y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
9941  proportional to the number of points in each bin. This is a PLFLT\n\
9942  (instead of PLINT) vector so as to allow histograms of\n\
9943  probabilities, etc.\n\
9944 \n\
9945  opt (PLINT, input) : Is a combination of several flags:\n\
9946  opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9947  outer bins are expanded to fill up the entire x-axis and bins of\n\
9948  zero height are simply drawn.\n\
9949  opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9950  between the x values. If the values in x are equally spaced,\n\
9951  the values are the center values of the bins.\n\
9952  opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9953  size as the ones inside.\n\
9954  opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9955  (there is a gap for such bins).\n\
9956 ";
9957 static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
9958 Plot a 2D matrix using cmap1\n\
9959 \n\
9960 DESCRIPTION:\n\
9961 \n\
9962  Plot a 2D matrix using cmap1.\n\
9963 \n\
9964  Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
9965  zmax, valuemin, valuemax, pltr, pltr_data)\n\
9966 \n\
9967 \n\
9968  This function is used in example 20.\n\
9969 \n\
9970 \n\
9971 \n\
9972 SYNOPSIS:\n\
9973 \n\
9974 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9975 \n\
9976 ARGUMENTS:\n\
9977 \n\
9978  idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
9979  plot. Should have dimensions of\n\
9980  nx by\n\
9981  ny.\n\
9982 \n\
9983  nx, ny (PLINT, input) : Dimensions of idata\n\
9984 \n\
9985  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
9986  pltr below for how these arguments are used (only for the special case\n\
9987  when the callback function\n\
9988  pltr is not supplied).\n\
9989 \n\
9990  zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9991  (inclusive) will be plotted.\n\
9992 \n\
9993  valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9994  values to use for value to color mappings. A datum equal to or\n\
9995  less than valuemin will be plotted with color 0.0, while a datum\n\
9996  equal to or greater than valuemax will be plotted with color 1.0.\n\
9997  Data between valuemin and valuemax map linearly to colors in the\n\
9998  range (0.0-1.0).\n\
9999 \n\
10000  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10001  defines the transformation between the zero-based indices of the\n\
10002  matrix idata and world coordinates. If\n\
10003  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10004  indices of idata are mapped to the range\n\
10005  xmin through\n\
10006  xmax and the y indices of idata are mapped to the range\n\
10007  ymin through\n\
10008  ymax.For the C case, transformation functions are provided in the\n\
10009  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10010  pltr2 for arbitrary mappings respectively defined by vectors and\n\
10011  matrices. In addition, C callback routines for the transformation\n\
10012  can be supplied by the user such as the mypltr function in\n\
10013  examples/c/x09c.c which provides a general linear transformation\n\
10014  between index coordinates and world coordinates.For languages\n\
10015  other than C you should consult the PLplot documentation for the\n\
10016  details concerning how PLTRANSFORM_callback arguments are\n\
10017  interfaced. However, in general, a particular pattern of\n\
10018  callback-associated arguments such as a tr vector with 6 elements;\n\
10019  xg and yg vectors; or xg and yg matrices are respectively\n\
10020  interfaced to a linear-transformation routine similar to the above\n\
10021  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10022  sophisticated bindings (see, e.g., the PLplot documentation)\n\
10023  support native language callbacks for handling index to\n\
10024  world-coordinate transformations. Examples of these various\n\
10025  approaches are given in examples/<language>x09*,\n\
10026  examples/<language>x16*, examples/<language>x20*,\n\
10027  examples/<language>x21*, and examples/<language>x22*, for all our\n\
10028  supported languages.\n\
10029 \n\
10030  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10031  information to pltr0, pltr1, pltr2, or whatever routine is\n\
10032  externally supplied.\n\
10033 ";
10034 static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
10035 Get family, style and weight of the current font\n\
10036 \n\
10037 DESCRIPTION:\n\
10038 \n\
10039  Gets information about current font. See the PLplot documentation for\n\
10040  more information on font selection.\n\
10041 \n\
10042  Redacted form: plgfont(p_family, p_style, p_weight)\n\
10043 \n\
10044  This function is used in example 23.\n\
10045 \n\
10046 \n\
10047 \n\
10048 SYNOPSIS:\n\
10049 \n\
10050 plgfont(p_family, p_style, p_weight)\n\
10051 \n\
10052 ARGUMENTS:\n\
10053 \n\
10054  p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10055  font family. The available values are given by the PL_FCI_*\n\
10056  constants in plplot.h. Current options are PL_FCI_SANS,\n\
10057  PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
10058  p_family is NULL then the font family is not returned.\n\
10059 \n\
10060  p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10061  font style. The available values are given by the PL_FCI_*\n\
10062  constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
10063  PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
10064  style is not returned.\n\
10065 \n\
10066  p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10067  font weight. The available values are given by the PL_FCI_*\n\
10068  constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
10069  PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
10070  returned.\n\
10071 ";
10072 static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
10073 Get z axis parameters\n\
10074 \n\
10075 DESCRIPTION:\n\
10076 \n\
10077  Identical to plgxax, except that arguments are flags for z axis. See\n\
10078  the description of plgxax for more detail.\n\
10079 \n\
10080  Redacted form: plgzax(p_digmax, p_digits)\n\
10081 \n\
10082  This function is used in example 31.\n\
10083 \n\
10084 \n\
10085 \n\
10086 SYNOPSIS:\n\
10087 \n\
10088 plgzax(p_digmax, p_digits)\n\
10089 \n\
10090 ARGUMENTS:\n\
10091 \n\
10092  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
10093  number of digits for the z axis. If nonzero, the printed label\n\
10094  has been switched to a floating-point representation when the\n\
10095  number of digits exceeds this value.\n\
10096 \n\
10097  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
10098  number of digits for the numeric labels (z axis) from the last\n\
10099  plot.\n\
10100 ";
10101 static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
10102 Write text inside the viewport of a 3D plot\n\
10103 \n\
10104 DESCRIPTION:\n\
10105 \n\
10106  Writes text at a specified position and inclination and with a\n\
10107  specified shear within the viewport. Text is clipped at the viewport\n\
10108  boundaries. The reference point of a string lies along a line passing\n\
10109  through the string at half the height of a capital letter. The\n\
10110  position of the reference point along this line is determined by just,\n\
10111  and the reference point is placed at world coordinates (\n\
10112  wx,\n\
10113  wy,\n\
10114  wz) within the viewport. The inclination and shear of the string is\n\
10115  specified in terms of differences of world coordinates making it easy\n\
10116  to write text parallel to a line in a graph.\n\
10117 \n\
10118  Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
10119 \n\
10120  This function is used in example 28.\n\
10121 \n\
10122 \n\
10123 \n\
10124 SYNOPSIS:\n\
10125 \n\
10126 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
10127 \n\
10128 ARGUMENTS:\n\
10129 \n\
10130  wx (PLFLT, input) : x world coordinate of reference point of\n\
10131  string.\n\
10132 \n\
10133  wy (PLFLT, input) : y world coordinate of reference point of\n\
10134  string.\n\
10135 \n\
10136  wz (PLFLT, input) : z world coordinate of reference point of\n\
10137  string.\n\
10138 \n\
10139  dx (PLFLT, input) : Together with dy and\n\
10140  dz , this specifies the inclination of the string. The baseline of\n\
10141  the string is parallel to a line joining (\n\
10142  x,\n\
10143  y,\n\
10144  z) to (\n\
10145  x+\n\
10146  dx,\n\
10147  y+\n\
10148  dy,\n\
10149  z+\n\
10150  dz) .\n\
10151 \n\
10152  dy (PLFLT, input) : Together with dx and\n\
10153  dz, this specifies the inclination of the string.\n\
10154 \n\
10155  dz (PLFLT, input) : Together with dx and\n\
10156  dy, this specifies the inclination of the string.\n\
10157 \n\
10158  sx (PLFLT, input) : Together with sy and\n\
10159  sz , this specifies the shear of the string. The string is sheared so\n\
10160  that the characters are vertically parallel to a line joining (\n\
10161  x,\n\
10162  y,\n\
10163  z) to (\n\
10164  x+\n\
10165  sx,\n\
10166  y+\n\
10167  sy,\n\
10168  z+\n\
10169  sz) . If sx =\n\
10170  sy =\n\
10171  sz = 0.) then the text is not sheared.\n\
10172 \n\
10173  sy (PLFLT, input) : Together with sx and\n\
10174  sz, this specifies shear of the string.\n\
10175 \n\
10176  sz (PLFLT, input) : Together with sx and\n\
10177  sy, this specifies shear of the string.\n\
10178 \n\
10179  just (PLFLT, input) : Specifies the position of the string relative\n\
10180  to its reference point. If just=0. , the reference point is at\n\
10181  the left and if just=1. , it is at the right of the string. Other\n\
10182  values of just give intermediate justifications.\n\
10183 \n\
10184  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
10185  written out.\n\
10186 ";
10187 static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
10188 Draw a box with axes, etc. with arbitrary origin\n\
10189 \n\
10190 DESCRIPTION:\n\
10191 \n\
10192  Draws a box around the currently defined viewport with arbitrary\n\
10193  world-coordinate origin specified by x0 and y0 and labels it with\n\
10194  world coordinate values appropriate to the window. Thus plaxes should\n\
10195  only be called after defining both viewport and window. The ascii\n\
10196  character strings xopt and yopt specify how the box should be drawn as\n\
10197  described below. If ticks and/or subticks are to be drawn for a\n\
10198  particular axis, the tick intervals and number of subintervals may be\n\
10199  specified explicitly, or they may be defaulted by setting the\n\
10200  appropriate arguments to zero.\n\
10201 \n\
10202  Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
10203  ytick, nysub)\n\
10204 \n\
10205 \n\
10206  This function is not used in any examples.\n\
10207 \n\
10208 \n\
10209 \n\
10210 SYNOPSIS:\n\
10211 \n\
10212 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
10213 \n\
10214 ARGUMENTS:\n\
10215 \n\
10216  x0 (PLFLT, input) : World X coordinate of origin.\n\
10217 \n\
10218  y0 (PLFLT, input) : World Y coordinate of origin.\n\
10219 \n\
10220  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10221  options for the x axis. The string can include any combination of\n\
10222  the following letters (upper or lower case) in any order: a: Draws\n\
10223  axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
10224  (x=0).\n\
10225  b: Draws bottom (X) or left (Y) edge of frame.\n\
10226  c: Draws top (X) or right (Y) edge of frame.\n\
10227  d: Plot labels as date / time. Values are assumed to be\n\
10228  seconds since the epoch (as used by gmtime).\n\
10229  f: Always use fixed point numeric labels.\n\
10230  g: Draws a grid at the major tick interval.\n\
10231  h: Draws a grid at the minor tick interval.\n\
10232  i: Inverts tick marks, so they are drawn outwards, rather than\n\
10233  inwards.\n\
10234  l: Labels axis logarithmically. This only affects the labels,\n\
10235  not the data, and so it is necessary to compute the logarithms\n\
10236  of data points before passing them to any of the drawing\n\
10237  routines.\n\
10238  m: Writes numeric labels at major tick intervals in the\n\
10239  unconventional location (above box for X, right of box for Y).\n\
10240  n: Writes numeric labels at major tick intervals in the\n\
10241  conventional location (below box for X, left of box for Y).\n\
10242  o: Use custom labelling function to generate axis label text.\n\
10243  The custom labelling function can be defined with the\n\
10244  plslabelfunc command.\n\
10245  s: Enables subticks between major ticks, only valid if t is\n\
10246  also specified.\n\
10247  t: Draws major ticks.\n\
10248  u: Exactly like \"b\" except don\'t draw edge line.\n\
10249  w: Exactly like \"c\" except don\'t draw edge line.\n\
10250  x: Exactly like \"t\" (including the side effect of the\n\
10251  numerical labels for the major ticks) except exclude drawing\n\
10252  the major and minor tick marks.\n\
10253 \n\
10254 \n\
10255  xtick (PLFLT, input) : World coordinate interval between major\n\
10256  ticks on the x axis. If it is set to zero, PLplot automatically\n\
10257  generates a suitable tick interval.\n\
10258 \n\
10259  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
10260  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10261  generates a suitable minor tick interval.\n\
10262 \n\
10263  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10264  options for the y axis. The string can include any combination of\n\
10265  the letters defined above for xopt, and in addition may contain:\n\
10266  v: Write numeric labels for the y axis parallel to the base of the\n\
10267  graph, rather than parallel to the axis.\n\
10268 \n\
10269 \n\
10270  ytick (PLFLT, input) : World coordinate interval between major\n\
10271  ticks on the y axis. If it is set to zero, PLplot automatically\n\
10272  generates a suitable tick interval.\n\
10273 \n\
10274  nysub (PLINT, input) : Number of subintervals between major y axis\n\
10275  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10276  generates a suitable minor tick interval.\n\
10277 ";
10278 static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
10279 Returns the background color (cmap0[0]) by 8-bit RGB value\n\
10280 \n\
10281 DESCRIPTION:\n\
10282 \n\
10283  Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
10284 \n\
10285  Redacted form: plgcolbg(r, g, b)\n\
10286 \n\
10287  This function is used in example 31.\n\
10288 \n\
10289 \n\
10290 \n\
10291 SYNOPSIS:\n\
10292 \n\
10293 plgcolbg(r, g, b)\n\
10294 \n\
10295 ARGUMENTS:\n\
10296 \n\
10297  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10298  in the range from 0 to 255.\n\
10299 \n\
10300  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10301  in the range from 0 to 255.\n\
10302 \n\
10303  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10304  in the range from 0 to 255.\n\
10305 ";
10306 static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
10307 Plot a glyph at the specified 3D points\n\
10308 \n\
10309 DESCRIPTION:\n\
10310 \n\
10311  Plot a glyph at the specified 3D points. (This function is largely\n\
10312  superseded by plstring3 which gives access to many[!] more glyphs.)\n\
10313  Set up the call to this function similar to what is done for plline3.\n\
10314  code=-1 means try to just draw a point. Right now it\'s just a move\n\
10315  and a draw at the same place. Not ideal, since a sufficiently\n\
10316  intelligent output device may optimize it away, or there may be faster\n\
10317  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
10318  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
10319  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
10320  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
10321  code <= 127 the corresponding printable ASCII character is plotted.\n\
10322 \n\
10323  Redacted form: plpoin3(x, y, z, code)\n\
10324 \n\
10325  This function is not used in any example.\n\
10326 \n\
10327 \n\
10328 \n\
10329 SYNOPSIS:\n\
10330 \n\
10331 plpoin3(n, x, y, z, code)\n\
10332 \n\
10333 ARGUMENTS:\n\
10334 \n\
10335  n (PLINT, input) : Number of points in the x and y vectors.\n\
10336 \n\
10337  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10338  points.\n\
10339 \n\
10340  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10341  points.\n\
10342 \n\
10343  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10344  points.\n\
10345 \n\
10346  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10347  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10348  each of the n points.\n\
10349 ";
10350 static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10351 Draw a polygon in 3 space\n\
10352 \n\
10353 DESCRIPTION:\n\
10354 \n\
10355  Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10356  like plline3, but differs from that function in that plpoly3 attempts\n\
10357  to determine if the polygon is viewable depending on the order of the\n\
10358  points within the vector and the value of ifcc. If the back of\n\
10359  polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10360  you want, then use plline3 instead.\n\
10361 \n\
10362  The points are assumed to be in a plane, and the directionality of the\n\
10363  plane is determined from the first three points. Additional points do\n\
10364  not have to lie on the plane defined by the first three, but if they\n\
10365  do not, then the determination of visibility obviously can\'t be 100%\n\
10366  accurate... So if you\'re 3 space polygons are too far from planar,\n\
10367  consider breaking them into smaller polygons. 3 points define a plane\n\
10368  :-).\n\
10369 \n\
10370  Bugs: If one of the first two segments is of zero length, or if they\n\
10371  are co-linear, the calculation of visibility has a 50/50 chance of\n\
10372  being correct. Avoid such situations :-). See x18c.c for an example\n\
10373  of this problem. (Search for 20.1).\n\
10374 \n\
10375  Redacted form: plpoly3(x, y, z, code)\n\
10376 \n\
10377  This function is used in example 18.\n\
10378 \n\
10379 \n\
10380 \n\
10381 SYNOPSIS:\n\
10382 \n\
10383 plpoly3(n, x, y, z, draw, ifcc)\n\
10384 \n\
10385 ARGUMENTS:\n\
10386 \n\
10387  n (PLINT, input) : Number of points defining line.\n\
10388 \n\
10389  x (PLFLT_VECTOR, input) : A vector containing\n\
10390  n x coordinates of points.\n\
10391 \n\
10392  y (PLFLT_VECTOR, input) : A vector containing\n\
10393  n y coordinates of points.\n\
10394 \n\
10395  z (PLFLT_VECTOR, input) : A vector containing\n\
10396  n z coordinates of points.\n\
10397 \n\
10398  draw (PLBOOL_VECTOR, input) : A vector containing\n\
10399  n-1 Boolean values which control drawing the segments of the polygon.\n\
10400  If draw[i] is true, then the polygon segment from index [i] to\n\
10401  [i+1] is drawn, otherwise, not.\n\
10402 \n\
10403  ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10404  polygon is determined by assuming the points are laid out in a\n\
10405  counter-clockwise order. Otherwise, the directionality of the\n\
10406  polygon is determined by assuming the points are laid out in a\n\
10407  clockwise order.\n\
10408 ";
10409 static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
10410 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10411 \n\
10412 DESCRIPTION:\n\
10413 \n\
10414  Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10415  PLFLT alpha transparency value (see the PLplot documentation).\n\
10416 \n\
10417  This function is used in example 31.\n\
10418 \n\
10419 \n\
10420 \n\
10421 SYNOPSIS:\n\
10422 \n\
10423 plscolbga(r, g, b, alpha)\n\
10424 \n\
10425 ARGUMENTS:\n\
10426 \n\
10427  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10428  degree of red in the color.\n\
10429 \n\
10430  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10431  degree of green in the color.\n\
10432 \n\
10433  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10434  degree of blue in the color.\n\
10435 \n\
10436  alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10437  (0.0-1.0).\n\
10438 ";
10439 static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
10440 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10441 \n\
10442 DESCRIPTION:\n\
10443 \n\
10444  Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10445  alpha transparency value.\n\
10446 \n\
10447  This function is used in example 31.\n\
10448 \n\
10449 \n\
10450 \n\
10451 SYNOPSIS:\n\
10452 \n\
10453 plgcolbga(r, g, b, alpha)\n\
10454 \n\
10455 ARGUMENTS:\n\
10456 \n\
10457  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10458  in the range from 0 to 255.\n\
10459 \n\
10460  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10461  in the range from 0 to 255.\n\
10462 \n\
10463  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10464  in the range from 0 to 255.\n\
10465 \n\
10466  alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10467  transparency in the range (0.0-1.0).\n\
10468 ";
10469 static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
10470 Draw error bars in x direction\n\
10471 \n\
10472 DESCRIPTION:\n\
10473 \n\
10474  Draws a set of n error bars in x direction, the i\'th error bar\n\
10475  extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10476  of the error bars are of length equal to the minor tick length\n\
10477  (settable using plsmin).\n\
10478 \n\
10479  Redacted form: General: plerrx(xmin, ymax, y)\n\
10480 \n\
10481 \n\
10482  This function is used in example 29.\n\
10483 \n\
10484 \n\
10485 \n\
10486 SYNOPSIS:\n\
10487 \n\
10488 plerrx(n, xmin, xmax, y)\n\
10489 \n\
10490 ARGUMENTS:\n\
10491 \n\
10492  n (PLINT, input) : Number of error bars to draw.\n\
10493 \n\
10494  xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10495  of the left-hand endpoints of the error bars.\n\
10496 \n\
10497  xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10498  of the right-hand endpoints of the error bars.\n\
10499 \n\
10500  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10501  the error bars.\n\
10502 ";
10503 static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
10504 Eject current page\n\
10505 \n\
10506 DESCRIPTION:\n\
10507 \n\
10508  Clears the graphics screen of an interactive device, or ejects a page\n\
10509  on a plotter. See plbop for more information.\n\
10510 \n\
10511  Redacted form: pleop()\n\
10512 \n\
10513  This function is used in example 2,14.\n\
10514 \n\
10515 \n\
10516 \n\
10517 SYNOPSIS:\n\
10518 \n\
10519 pleop()\n\
10520 ";
10521 static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
10522 Convert HLS color to RGB\n\
10523 \n\
10524 DESCRIPTION:\n\
10525 \n\
10526  Convert HLS color coordinates to RGB.\n\
10527 \n\
10528  Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10529 \n\
10530 \n\
10531  This function is used in example 2.\n\
10532 \n\
10533 \n\
10534 \n\
10535 SYNOPSIS:\n\
10536 \n\
10537 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10538 \n\
10539 ARGUMENTS:\n\
10540 \n\
10541  h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10542  cylinder.\n\
10543 \n\
10544  l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10545  the axis of the color cylinder.\n\
10546 \n\
10547  s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10548  the radius of the color cylinder.\n\
10549 \n\
10550  p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10551  (0.0-1.0) of the color.\n\
10552 \n\
10553  p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10554  intensity (0.0-1.0) of the color.\n\
10555 \n\
10556  p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10557  intensity (0.0-1.0) of the color.\n\
10558 ";
10559 static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
10560 Plot all or a subset of Shapefile data, filling the polygons\n\
10561 \n\
10562 DESCRIPTION:\n\
10563 \n\
10564  As per plmapline, however the items are filled in the same way as\n\
10565  plfill.\n\
10566 \n\
10567  Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10568  plotentries)\n\
10569 \n\
10570  This function is used in example 19.\n\
10571 \n\
10572 \n\
10573 \n\
10574 SYNOPSIS:\n\
10575 \n\
10576 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10577 \n\
10578 ARGUMENTS:\n\
10579 \n\
10580  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10581  transform the coordinates given in the shapefile into a plot\n\
10582  coordinate system. By using this transform, we can change from a\n\
10583  longitude, latitude coordinate to a polar stereographic project,\n\
10584  for example. Initially, x[0]..[n-1] are the longitudes and\n\
10585  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10586  mapform(), x[] and y[] should be replaced by the corresponding\n\
10587  plot coordinates. If no transform is desired, mapform can be\n\
10588  replaced by NULL.\n\
10589 \n\
10590  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10591  the file name of a set of Shapefile files without the file\n\
10592  extension.\n\
10593 \n\
10594  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10595  be in the same units as used by the Shapefile. You could use a\n\
10596  very large negative number to plot everything, but you can improve\n\
10597  performance by limiting the area drawn. The units must match those\n\
10598  of the Shapefile projection, which may be for example longitude or\n\
10599  distance. The value of minx must be less than the value of maxx.\n\
10600 \n\
10601  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10602  use a very large number to plot everything, but you can improve\n\
10603  performance by limiting the area drawn.\n\
10604 \n\
10605  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10606  be in the same units as used by the Shapefile. You could use a\n\
10607  very large negative number to plot everything, but you can improve\n\
10608  performance by limiting the area drawn. The units must match those\n\
10609  of the Shapefile projection, which may be for example latitude or\n\
10610  distance. The value of miny must be less than the value of maxy.\n\
10611 \n\
10612  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10613  use a very large number to plot everything, but you can improve\n\
10614  performance by limiting the area drawn.\n\
10615 \n\
10616  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10617  zero-based indices of the Shapefile elements which will be drawn.\n\
10618  Setting\n\
10619  plotentries to NULL will plot all elements of the Shapefile.\n\
10620 \n\
10621  nplotentries (PLINT, input) : The number of items in\n\
10622  plotentries. Ignored if\n\
10623  plotentries is NULL.\n\
10624 ";
10625 static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
10626 Draw error bars in the y direction\n\
10627 \n\
10628 DESCRIPTION:\n\
10629 \n\
10630  Draws a set of n error bars in the y direction, the i\'th error bar\n\
10631  extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10632  of the error bars are of length equal to the minor tick length\n\
10633  (settable using plsmin).\n\
10634 \n\
10635  Redacted form: General: plerry(x, ymin, ymax)\n\
10636 \n\
10637 \n\
10638  This function is used in example 29.\n\
10639 \n\
10640 \n\
10641 \n\
10642 SYNOPSIS:\n\
10643 \n\
10644 plerry(n, x, ymin, ymax)\n\
10645 \n\
10646 ARGUMENTS:\n\
10647 \n\
10648  n (PLINT, input) : Number of error bars to draw.\n\
10649 \n\
10650  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10651  the error bars.\n\
10652 \n\
10653  ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10654  of the lower endpoints of the error bars.\n\
10655 \n\
10656  ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10657  of the upper endpoints of the error bars.\n\
10658 ";
10659 static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
10660 Set FCI (font characterization integer)\n\
10661 \n\
10662 DESCRIPTION:\n\
10663 \n\
10664  Sets font characteristics to be used at the start of the next string\n\
10665  using the FCI approach. See the PLplot documentation for more\n\
10666  information. Note, plsfont (which calls plsfci internally) provides a\n\
10667  more user-friendly API for setting the font characterisitics.\n\
10668 \n\
10669  Redacted form: General: plsfci(fci)\n\
10670 \n\
10671 \n\
10672  This function is used in example 23.\n\
10673 \n\
10674 \n\
10675 \n\
10676 SYNOPSIS:\n\
10677 \n\
10678 plsfci(fci)\n\
10679 \n\
10680 ARGUMENTS:\n\
10681 \n\
10682  fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10683  of FCI.\n\
10684 ";
10685 static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
10686 Select area fill pattern\n\
10687 \n\
10688 DESCRIPTION:\n\
10689 \n\
10690  If\n\
10691  patt is zero or less use either a hardware solid fill if the drivers\n\
10692  have that capability (virtually all do) or fall back to a software\n\
10693  emulation of a solid fill using the eighth area line fill pattern. If\n\
10694  0 <\n\
10695  patt <= 8, then select one of eight predefined area line fill patterns\n\
10696  to use (see plpat if you desire other patterns).\n\
10697 \n\
10698  Redacted form: plpsty(patt)\n\
10699 \n\
10700  This function is used in examples 12, 13, 15, 16, and 25.\n\
10701 \n\
10702 \n\
10703 \n\
10704 SYNOPSIS:\n\
10705 \n\
10706 plpsty(patt)\n\
10707 \n\
10708 ARGUMENTS:\n\
10709 \n\
10710  patt (PLINT, input) : The desired pattern index. If\n\
10711  patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10712  above) used. For\n\
10713  patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10714  line fill capability itself (most deliberately do not so that line\n\
10715  fill patterns look identical for those drivers), the patterns\n\
10716  consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10717  45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10718  lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10719  (8) lines at both 45 degrees and -45 degrees.\n\
10720 ";
10721 static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
10722 Set symbol size\n\
10723 \n\
10724 DESCRIPTION:\n\
10725 \n\
10726  This sets up the size of all subsequent symbols drawn by plpoin and\n\
10727  plsym. The actual height of a symbol is the product of the default\n\
10728  symbol size and a scaling factor as for the character height.\n\
10729 \n\
10730  Redacted form: plssym(def, scale)\n\
10731 \n\
10732  This function is used in example 29.\n\
10733 \n\
10734 \n\
10735 \n\
10736 SYNOPSIS:\n\
10737 \n\
10738 plssym(def, scale)\n\
10739 \n\
10740 ARGUMENTS:\n\
10741 \n\
10742  def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10743  should be set to zero if the default height is to remain\n\
10744  unchanged.\n\
10745 \n\
10746  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10747  actual symbol height.\n\
10748 ";
10749 static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
10750 Initialization\n\
10751 \n\
10752 DESCRIPTION:\n\
10753 \n\
10754  Alternative to plstar for initializing the plotting package. The\n\
10755  device name keyword for the desired output device must be supplied as\n\
10756  an argument. These keywords are the same as those printed out by\n\
10757  plstar. If the requested device is not available, or if the input\n\
10758  string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10759  is used. This routine also divides the output device page into nx by\n\
10760  ny subpages, each of which may be used independently. The subroutine\n\
10761  pladv is used to advance from one subpage to the next.\n\
10762 \n\
10763  Redacted form: General: plstart(devname, nx, ny)\n\
10764 \n\
10765 \n\
10766  This function is not used in any examples.\n\
10767 \n\
10768 \n\
10769 \n\
10770 SYNOPSIS:\n\
10771 \n\
10772 plstart(devname, nx, ny)\n\
10773 \n\
10774 ARGUMENTS:\n\
10775 \n\
10776  devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10777  containing the device name keyword of the required output device.\n\
10778  If\n\
10779  devname is NULL or if the first character of the string is a ``?\'\',\n\
10780  the normal (prompted) start up is used.\n\
10781 \n\
10782  nx (PLINT, input) : Number of subpages to divide output page in the\n\
10783  x direction.\n\
10784 \n\
10785  ny (PLINT, input) : Number of subpages to divide output page in the\n\
10786  y direction.\n\
10787 ";
10788 
10789 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10790  PLINT arg1 ;
10791  PLINT *arg2 = (PLINT *) 0 ;
10792  char **arg3 = (char **) 0 ;
10793  Matrix temp1 ;
10794  octave_value_list _out;
10795  octave_value_list *_outp=&_out;
10796  octave_value _outv;
10797 
10798  try {
10799  if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10800  SWIG_fail;
10801  }
10802  {
10803  if ( _n_dims( args(0) ) > 1 )
10804  {
10805  error( "argument must be a scalar or vector" ); SWIG_fail;
10806  }
10807  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10808  arg2 = new PLINT[Alen];
10809  temp1 = args(0).matrix_value();
10810  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10811  }
10812  {
10813  charMatrix temp_matrix;
10814  Cell temp_cell;
10815  char *tmp_cstring;
10816  std::string str;
10817  size_t max_length = 0, non_blank_length;
10818  int i, ifcell;
10819  if ( _n_dims( args(1) ) > 2 )
10820  {
10821  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10822  }
10823 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10824  if ( !args(1).isempty() )
10825 #else
10826  if ( !args(1).is_empty() )
10827 #endif
10828  {
10829  if ( _dim( args(1), 0 ) != Alen )
10830  {
10831  error( "first dimension must be same length as previous vector" ); SWIG_fail;
10832  }
10833  arg3 = new char*[Alen];
10834 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10835  ifcell = args(1).iscell();
10836 #else
10837  ifcell = args(1).is_cell();
10838 #endif
10839  if ( ifcell )
10840  {
10841  temp_cell = args(1).cell_value();
10842  }
10843  else
10844  {
10845  temp_matrix = args(1).char_matrix_value();
10846  // Allow one extra space for null termination.
10847  max_length = _dim( args(1), 1 ) + 1;
10848  }
10849 
10850  for ( i = 0; i < Alen; i++ )
10851  {
10852  // Must copy string to "permanent" location because the string
10853  // location corresponding to tmp_cstring gets
10854  // overwritten for each iteration of loop.
10855  if ( ifcell )
10856  {
10857  if ( temp_cell.elem( i ).is_string() )
10858  {
10859  str = temp_cell.elem( i ).string_value();
10860  // leave room for null termination.
10861  max_length = str.size() + 1;
10862  tmp_cstring = (char *) str.c_str();
10863  }
10864  else
10865  {
10866  // Use null string if user attempts to pass a cell array
10867  // with a non-string element (likely an empty element
10868  // since that should be allowed by the PLplot interface
10869  // if that element is going to be unused).
10870  // leave room for null termination.
10871  max_length = 1;
10872  tmp_cstring = (char *) "";
10873  }
10874  }
10875  else
10876  {
10877  str = temp_matrix.row_as_string( i );
10878  tmp_cstring = (char *) str.c_str();
10879  }
10880  arg3[i] = new char[max_length];
10881  strncpy( arg3[i], tmp_cstring, max_length - 1 );
10882  arg3[i][max_length - 1] = '\0';
10883  // All the trailing blank crapola should not be needed for
10884  // string cell arrays.
10885  if ( !ifcell )
10886  {
10887  // remove trailing-blank padding that is used by the
10888  // charMatrix class to insure all strings in a given
10889  // charMatrix instance have the same length.
10890  // This transformation also removes legitimate trailing
10891  // blanks but there is nothing we can do about that
10892  // for the charMatrix class.
10893 
10894  // Look for trailing nulls first (just in case, although that
10895  // shouldn't happen if charMatrix implemented as documented)
10896  // before looking for trailing blanks.
10897  non_blank_length = max_length - 2;
10898  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
10899  {
10900  non_blank_length--;
10901  }
10902  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
10903  {
10904  non_blank_length--;
10905  }
10906  arg3[i][non_blank_length + 1] = '\0';
10907  }
10908  }
10909  }
10910  else
10911  {
10912  arg3 = NULL;
10913  }
10914  }
10915  testppchar(arg1,(int const *)arg2,(char const **)arg3);
10916  _outv = octave_value();
10917  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10918  {
10919  delete [] arg2;
10920  }
10921  {
10922  int i;
10923  if ( arg3 != NULL )
10924  {
10925  for ( i = 0; i < Alen; i++ )
10926  {
10927  delete[] arg3[i];
10928  }
10929  delete[] arg3;
10930  }
10931  }
10932  return _out;
10933  fail:
10934  {
10935  delete [] arg2;
10936  }
10937  {
10938  int i;
10939  if ( arg3 != NULL )
10940  {
10941  for ( i = 0; i < Alen; i++ )
10942  {
10943  delete[] arg3[i];
10944  }
10945  delete[] arg3;
10946  }
10947  }
10948  return octave_value_list();
10949  }
10950  catch(...) {
10951  {
10952  delete [] arg2;
10953  }
10954  {
10955  int i;
10956  if ( arg3 != NULL )
10957  {
10958  for ( i = 0; i < Alen; i++ )
10959  {
10960  delete[] arg3[i];
10961  }
10962  delete[] arg3;
10963  }
10964  }
10965  throw;
10966  }
10967 }
10968 
10969 
10971  int *arg1 = (int *) 0 ;
10972  int *arg2 = (int *) 0 ;
10973  int *arg3 = (int *) 0 ;
10974  char *arg4 = (char *) 0 ;
10975  int *arg5 = (int *) 0 ;
10976  int *arg6 = (int *) 0 ;
10977  PLFLT *arg7 = (PLFLT *) 0 ;
10978  PLFLT *arg8 = (PLFLT *) 0 ;
10979  PLFLT *arg9 = (PLFLT *) 0 ;
10980  PLFLT *arg10 = (PLFLT *) 0 ;
10981  int *arg11 = (int *) 0 ;
10982  int temp1 ;
10983  int res1 = SWIG_TMPOBJ ;
10984  int temp2 ;
10985  int res2 = SWIG_TMPOBJ ;
10986  int temp3 ;
10987  int res3 = SWIG_TMPOBJ ;
10988  char local_string4[80] ;
10989  int temp5 ;
10990  int res5 = SWIG_TMPOBJ ;
10991  int temp6 ;
10992  int res6 = SWIG_TMPOBJ ;
10993  PLFLT temp7 ;
10994  int res7 = SWIG_TMPOBJ ;
10995  PLFLT temp8 ;
10996  int res8 = SWIG_TMPOBJ ;
10997  PLFLT temp9 ;
10998  int res9 = SWIG_TMPOBJ ;
10999  PLFLT temp10 ;
11000  int res10 = SWIG_TMPOBJ ;
11001  int temp11 ;
11002  int res11 = SWIG_TMPOBJ ;
11003  size_t local_string_length4 ;
11004  charMatrix local_charMatrix4 ;
11005  octave_value_list retval4 ;
11006  octave_value_list _out;
11007  octave_value_list *_outp=&_out;
11008  octave_value _outv;
11009  int result;
11010 
11011  try {
11012  arg1 = &temp1;
11013  arg2 = &temp2;
11014  arg3 = &temp3;
11015  {
11016  arg4 = local_string4;
11017  }
11018  arg5 = &temp5;
11019  arg6 = &temp6;
11020  arg7 = &temp7;
11021  arg8 = &temp8;
11022  arg9 = &temp9;
11023  arg10 = &temp10;
11024  arg11 = &temp11;
11025  if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
11026  SWIG_fail;
11027  }
11028  result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11029  _outv = SWIG_From_int(static_cast< int >(result));
11030  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11031  if (SWIG_IsTmpObj(res1)) {
11032  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11033  } else {
11034  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11035  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11036  }
11037  if (SWIG_IsTmpObj(res2)) {
11038  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
11039  } else {
11040  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11041  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
11042  }
11043  if (SWIG_IsTmpObj(res3)) {
11044  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
11045  } else {
11046  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11047  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11048  }
11049  {
11050  local_string_length4 = strlen( local_string4 );
11051  local_charMatrix4 = charMatrix( 1, local_string_length4 );
11052  local_charMatrix4.insert( local_string4, 0, 0 );
11053  retval4( 0 ) = octave_value( local_charMatrix4 );
11054  _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
11055  }
11056  if (SWIG_IsTmpObj(res5)) {
11057  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11058  } else {
11059  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11060  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11061  }
11062  if (SWIG_IsTmpObj(res6)) {
11063  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11064  } else {
11065  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11066  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11067  }
11068  if (SWIG_IsTmpObj(res7)) {
11069  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11070  } else {
11071  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11072  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11073  }
11074  if (SWIG_IsTmpObj(res8)) {
11075  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11076  } else {
11077  int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11078  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11079  }
11080  if (SWIG_IsTmpObj(res9)) {
11081  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11082  } else {
11083  int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11084  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11085  }
11086  if (SWIG_IsTmpObj(res10)) {
11087  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11088  } else {
11089  int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11090  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11091  }
11092  if (SWIG_IsTmpObj(res11)) {
11093  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11094  } else {
11095  int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11096  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11097  }
11098  return _out;
11099  fail:
11100  return octave_value_list();
11101  }
11102  catch(...) {
11103  throw;
11104  }
11105 }
11106 
11107 
11108 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11109  PLFLT *arg1 = (PLFLT *) 0 ;
11110  PLFLT *arg2 = (PLFLT *) 0 ;
11111  PLFLT arg3 ;
11112  PLFLT arg4 ;
11113  PLFLT temp1 ;
11114  int res1 = SWIG_TMPOBJ ;
11115  PLFLT temp2 ;
11116  int res2 = SWIG_TMPOBJ ;
11117  double val3 ;
11118  int ecode3 = 0 ;
11119  double val4 ;
11120  int ecode4 = 0 ;
11121  octave_value_list _out;
11122  octave_value_list *_outp=&_out;
11123  octave_value _outv;
11124  int result;
11125 
11126  try {
11127  arg1 = &temp1;
11128  arg2 = &temp2;
11129  if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11130  SWIG_fail;
11131  }
11132  ecode3 = SWIG_AsVal_double(args(0), &val3);
11133  if (!SWIG_IsOK(ecode3)) {
11134  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11135  }
11136  arg3 = static_cast< PLFLT >(val3);
11137  ecode4 = SWIG_AsVal_double(args(1), &val4);
11138  if (!SWIG_IsOK(ecode4)) {
11139  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11140  }
11141  arg4 = static_cast< PLFLT >(val4);
11142  result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11143  _outv = SWIG_From_int(static_cast< int >(result));
11144  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11145  if (SWIG_IsTmpObj(res1)) {
11146  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11147  } else {
11148  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11149  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11150  }
11151  if (SWIG_IsTmpObj(res2)) {
11152  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11153  } else {
11154  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11155  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11156  }
11157  return _out;
11158  fail:
11159  return octave_value_list();
11160  }
11161  catch(...) {
11162  throw;
11163  }
11164 }
11165 
11166 
11168  PLINT *arg1 = (PLINT *) 0 ;
11169  char *arg2 = (char *) 0 ;
11170  char *arg3 = (char *) 0 ;
11171  PLFLT arg4 ;
11172  PLFLT arg5 ;
11173  PLFLT arg6 ;
11174  PLFLT arg7 ;
11175  PLFLT arg8 ;
11176  PLFLT arg9 ;
11177  PLFLT arg10 ;
11178  PLBOOL arg11 ;
11179  PLBOOL arg12 ;
11180  PLINT arg13 ;
11181  PLINT arg14 ;
11182  PLINT *arg15 = (PLINT *) 0 ;
11183  PLINT *arg16 = (PLINT *) 0 ;
11184  char *arg17 = (char *) 0 ;
11185  char *arg18 = (char *) 0 ;
11186  char *arg19 = (char *) 0 ;
11187  char *arg20 = (char *) 0 ;
11188  char *arg21 = (char *) 0 ;
11189  char *arg22 = (char *) 0 ;
11190  char *arg23 = (char *) 0 ;
11191  PLINT temp1 ;
11192  int res1 = SWIG_TMPOBJ ;
11193  int res2 ;
11194  char *buf2 = 0 ;
11195  int alloc2 = 0 ;
11196  int res3 ;
11197  char *buf3 = 0 ;
11198  int alloc3 = 0 ;
11199  double val4 ;
11200  int ecode4 = 0 ;
11201  double val5 ;
11202  int ecode5 = 0 ;
11203  double val6 ;
11204  int ecode6 = 0 ;
11205  double val7 ;
11206  int ecode7 = 0 ;
11207  double val8 ;
11208  int ecode8 = 0 ;
11209  double val9 ;
11210  int ecode9 = 0 ;
11211  double val10 ;
11212  int ecode10 = 0 ;
11213  int val11 ;
11214  int ecode11 = 0 ;
11215  int val12 ;
11216  int ecode12 = 0 ;
11217  int val13 ;
11218  int ecode13 = 0 ;
11219  int val14 ;
11220  int ecode14 = 0 ;
11221  Matrix temp15 ;
11222  Matrix temp16 ;
11223  int res17 ;
11224  char *buf17 = 0 ;
11225  int alloc17 = 0 ;
11226  int res18 ;
11227  char *buf18 = 0 ;
11228  int alloc18 = 0 ;
11229  int res19 ;
11230  char *buf19 = 0 ;
11231  int alloc19 = 0 ;
11232  int res20 ;
11233  char *buf20 = 0 ;
11234  int alloc20 = 0 ;
11235  int res21 ;
11236  char *buf21 = 0 ;
11237  int alloc21 = 0 ;
11238  int res22 ;
11239  char *buf22 = 0 ;
11240  int alloc22 = 0 ;
11241  int res23 ;
11242  char *buf23 = 0 ;
11243  int alloc23 = 0 ;
11244  octave_value_list _out;
11245  octave_value_list *_outp=&_out;
11246  octave_value _outv;
11247 
11248  try {
11249  arg1 = &temp1;
11250  if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11251  SWIG_fail;
11252  }
11253  res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11254  if (!SWIG_IsOK(res2)) {
11255  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11256  }
11257  arg2 = reinterpret_cast< char * >(buf2);
11258  res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11259  if (!SWIG_IsOK(res3)) {
11260  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11261  }
11262  arg3 = reinterpret_cast< char * >(buf3);
11263  ecode4 = SWIG_AsVal_double(args(2), &val4);
11264  if (!SWIG_IsOK(ecode4)) {
11265  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11266  }
11267  arg4 = static_cast< PLFLT >(val4);
11268  ecode5 = SWIG_AsVal_double(args(3), &val5);
11269  if (!SWIG_IsOK(ecode5)) {
11270  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11271  }
11272  arg5 = static_cast< PLFLT >(val5);
11273  ecode6 = SWIG_AsVal_double(args(4), &val6);
11274  if (!SWIG_IsOK(ecode6)) {
11275  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11276  }
11277  arg6 = static_cast< PLFLT >(val6);
11278  ecode7 = SWIG_AsVal_double(args(5), &val7);
11279  if (!SWIG_IsOK(ecode7)) {
11280  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11281  }
11282  arg7 = static_cast< PLFLT >(val7);
11283  ecode8 = SWIG_AsVal_double(args(6), &val8);
11284  if (!SWIG_IsOK(ecode8)) {
11285  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11286  }
11287  arg8 = static_cast< PLFLT >(val8);
11288  ecode9 = SWIG_AsVal_double(args(7), &val9);
11289  if (!SWIG_IsOK(ecode9)) {
11290  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11291  }
11292  arg9 = static_cast< PLFLT >(val9);
11293  ecode10 = SWIG_AsVal_double(args(8), &val10);
11294  if (!SWIG_IsOK(ecode10)) {
11295  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11296  }
11297  arg10 = static_cast< PLFLT >(val10);
11298  ecode11 = SWIG_AsVal_int(args(9), &val11);
11299  if (!SWIG_IsOK(ecode11)) {
11300  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11301  }
11302  arg11 = static_cast< PLBOOL >(val11);
11303  ecode12 = SWIG_AsVal_int(args(10), &val12);
11304  if (!SWIG_IsOK(ecode12)) {
11305  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11306  }
11307  arg12 = static_cast< PLBOOL >(val12);
11308  ecode13 = SWIG_AsVal_int(args(11), &val13);
11309  if (!SWIG_IsOK(ecode13)) {
11310  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11311  }
11312  arg13 = static_cast< PLINT >(val13);
11313  ecode14 = SWIG_AsVal_int(args(12), &val14);
11314  if (!SWIG_IsOK(ecode14)) {
11315  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11316  }
11317  arg14 = static_cast< PLINT >(val14);
11318  {
11319  if ( _n_dims( args(13) ) > 1 )
11320  {
11321  error( "argument must be a scalar or vector" ); SWIG_fail;
11322  }
11323  Alen = (PLINT) ( _dim( args(13), 0 ) );
11324  temp15 = args(13).matrix_value();
11325  arg15 = new PLINT[Alen];
11326  _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11327  }
11328  {
11329  if ( _n_dims( args(14) ) > 1 )
11330  {
11331  error( "argument must be a scalar or vector" ); SWIG_fail;
11332  }
11333  if ( _dim( args(14), 0 ) != Alen )
11334  {
11335  error( "argument vectors must be same length" ); SWIG_fail;
11336  }
11337  temp16 = args(14).matrix_value();
11338  arg16 = new PLINT[Alen];
11339  _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11340  }
11341  res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11342  if (!SWIG_IsOK(res17)) {
11343  SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11344  }
11345  arg17 = reinterpret_cast< char * >(buf17);
11346  res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11347  if (!SWIG_IsOK(res18)) {
11348  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11349  }
11350  arg18 = reinterpret_cast< char * >(buf18);
11351  res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11352  if (!SWIG_IsOK(res19)) {
11353  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11354  }
11355  arg19 = reinterpret_cast< char * >(buf19);
11356  res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11357  if (!SWIG_IsOK(res20)) {
11358  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11359  }
11360  arg20 = reinterpret_cast< char * >(buf20);
11361  res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11362  if (!SWIG_IsOK(res21)) {
11363  SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11364  }
11365  arg21 = reinterpret_cast< char * >(buf21);
11366  res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11367  if (!SWIG_IsOK(res22)) {
11368  SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11369  }
11370  arg22 = reinterpret_cast< char * >(buf22);
11371  res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11372  if (!SWIG_IsOK(res23)) {
11373  SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11374  }
11375  arg23 = reinterpret_cast< char * >(buf23);
11376  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);
11377  _outv = octave_value();
11378  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11379  if (SWIG_IsTmpObj(res1)) {
11380  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11381  } else {
11382  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11383  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11384  }
11385  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11386  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11387  {
11388  delete [] arg15;
11389  }
11390  {
11391  delete [] arg16;
11392  }
11393  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11394  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11395  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11396  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11397  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11398  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11399  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11400  return _out;
11401  fail:
11402  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11403  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11404  {
11405  delete [] arg15;
11406  }
11407  {
11408  delete [] arg16;
11409  }
11410  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11411  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11412  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11413  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11414  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11415  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11416  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11417  return octave_value_list();
11418  }
11419  catch(...) {
11420  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11421  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11422  {
11423  delete [] arg15;
11424  }
11425  {
11426  delete [] arg16;
11427  }
11428  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11429  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11430  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11431  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11432  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11433  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11434  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11435  throw;
11436  }
11437 }
11438 
11439 
11441  PLFLT *arg1 = (PLFLT *) 0 ;
11442  PLINT arg2 ;
11443  PLINT arg3 ;
11444  PLINT arg4 ;
11445  PLINT arg5 ;
11446  PLINT arg6 ;
11447  PLINT arg7 ;
11448  PLFLT *arg8 = (PLFLT *) 0 ;
11449  PLINT arg9 ;
11450  PLFLT *arg10 = (PLFLT *) 0 ;
11451  Matrix temp1 ;
11452  int val4 ;
11453  int ecode4 = 0 ;
11454  int val5 ;
11455  int ecode5 = 0 ;
11456  int val6 ;
11457  int ecode6 = 0 ;
11458  int val7 ;
11459  int ecode7 = 0 ;
11460  Matrix temp8 ;
11461  Matrix temp10 ;
11462  octave_value_list _out;
11463  octave_value_list *_outp=&_out;
11464  octave_value _outv;
11465 
11466  try {
11467  if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11468  SWIG_fail;
11469  }
11470  {
11471  if ( _n_dims( args(0) ) > 2 )
11472  {
11473  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11474  }
11475  temp1 = args(0).matrix_value();
11476  arg1 = &temp1( 0, 0 );
11477  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11478  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11479  }
11480  ecode4 = SWIG_AsVal_int(args(1), &val4);
11481  if (!SWIG_IsOK(ecode4)) {
11482  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11483  }
11484  arg4 = static_cast< PLINT >(val4);
11485  ecode5 = SWIG_AsVal_int(args(2), &val5);
11486  if (!SWIG_IsOK(ecode5)) {
11487  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11488  }
11489  arg5 = static_cast< PLINT >(val5);
11490  ecode6 = SWIG_AsVal_int(args(3), &val6);
11491  if (!SWIG_IsOK(ecode6)) {
11492  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11493  }
11494  arg6 = static_cast< PLINT >(val6);
11495  ecode7 = SWIG_AsVal_int(args(4), &val7);
11496  if (!SWIG_IsOK(ecode7)) {
11497  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11498  }
11499  arg7 = static_cast< PLINT >(val7);
11500  {
11501  if ( _n_dims( args(5) ) > 1 )
11502  {
11503  error( "argument must be a scalar or vector" ); SWIG_fail;
11504  }
11505  temp8 = args(5).matrix_value();
11506  arg8 = &temp8( 0, 0 );
11507  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11508  }
11509  {
11510  if ( _n_dims( args(6) ) > 1 )
11511  {
11512  error( "argument must be a scalar or vector" ); SWIG_fail;
11513  }
11514  if ( _dim( args(6), 0 ) != 6 )
11515  {
11516  error( "argument vectors must have length of 6" ); SWIG_fail;
11517  }
11518  temp10 = args(6).matrix_value();
11519  arg10 = &temp10( 0, 0 );
11520  }
11521  my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11522  _outv = octave_value();
11523  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11524  {
11525 
11526  }
11527  {
11528 
11529  }
11530  {
11531 
11532  }
11533  return _out;
11534  fail:
11535  {
11536 
11537  }
11538  {
11539 
11540  }
11541  {
11542 
11543  }
11544  return octave_value_list();
11545  }
11546  catch(...) {
11547  {
11548 
11549  }
11550  {
11551 
11552  }
11553  {
11554 
11555  }
11556  throw;
11557  }
11558 }
11559 
11560 
11561 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11562  PLFLT *arg1 = (PLFLT *) 0 ;
11563  PLINT arg2 ;
11564  PLINT arg3 ;
11565  PLINT arg4 ;
11566  PLINT arg5 ;
11567  PLINT arg6 ;
11568  PLINT arg7 ;
11569  PLFLT *arg8 = (PLFLT *) 0 ;
11570  PLINT arg9 ;
11571  Matrix temp1 ;
11572  int val4 ;
11573  int ecode4 = 0 ;
11574  int val5 ;
11575  int ecode5 = 0 ;
11576  int val6 ;
11577  int ecode6 = 0 ;
11578  int val7 ;
11579  int ecode7 = 0 ;
11580  Matrix temp8 ;
11581  octave_value_list _out;
11582  octave_value_list *_outp=&_out;
11583  octave_value _outv;
11584 
11585  try {
11586  if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11587  SWIG_fail;
11588  }
11589  {
11590  if ( _n_dims( args(0) ) > 2 )
11591  {
11592  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11593  }
11594  temp1 = args(0).matrix_value();
11595  arg1 = &temp1( 0, 0 );
11596  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11597  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11598  }
11599  ecode4 = SWIG_AsVal_int(args(1), &val4);
11600  if (!SWIG_IsOK(ecode4)) {
11601  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11602  }
11603  arg4 = static_cast< PLINT >(val4);
11604  ecode5 = SWIG_AsVal_int(args(2), &val5);
11605  if (!SWIG_IsOK(ecode5)) {
11606  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11607  }
11608  arg5 = static_cast< PLINT >(val5);
11609  ecode6 = SWIG_AsVal_int(args(3), &val6);
11610  if (!SWIG_IsOK(ecode6)) {
11611  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11612  }
11613  arg6 = static_cast< PLINT >(val6);
11614  ecode7 = SWIG_AsVal_int(args(4), &val7);
11615  if (!SWIG_IsOK(ecode7)) {
11616  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11617  }
11618  arg7 = static_cast< PLINT >(val7);
11619  {
11620  if ( _n_dims( args(5) ) > 1 )
11621  {
11622  error( "argument must be a scalar or vector" ); SWIG_fail;
11623  }
11624  temp8 = args(5).matrix_value();
11625  arg8 = &temp8( 0, 0 );
11626  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11627  }
11628  my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11629  _outv = octave_value();
11630  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11631  {
11632 
11633  }
11634  {
11635 
11636  }
11637  return _out;
11638  fail:
11639  {
11640 
11641  }
11642  {
11643 
11644  }
11645  return octave_value_list();
11646  }
11647  catch(...) {
11648  {
11649 
11650  }
11651  {
11652 
11653  }
11654  throw;
11655  }
11656 }
11657 
11658 
11659 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11660  PLFLT *arg1 = (PLFLT *) 0 ;
11661  PLINT arg2 ;
11662  PLINT arg3 ;
11663  PLINT arg4 ;
11664  PLINT arg5 ;
11665  PLINT arg6 ;
11666  PLINT arg7 ;
11667  PLFLT *arg8 = (PLFLT *) 0 ;
11668  PLINT arg9 ;
11669  PLFLT *arg10 = (PLFLT *) 0 ;
11670  PLFLT *arg11 = (PLFLT *) 0 ;
11671  Matrix temp1 ;
11672  int val4 ;
11673  int ecode4 = 0 ;
11674  int val5 ;
11675  int ecode5 = 0 ;
11676  int val6 ;
11677  int ecode6 = 0 ;
11678  int val7 ;
11679  int ecode7 = 0 ;
11680  Matrix temp8 ;
11681  Matrix temp10 ;
11682  Matrix temp11 ;
11683  octave_value_list _out;
11684  octave_value_list *_outp=&_out;
11685  octave_value _outv;
11686 
11687  try {
11688  if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11689  SWIG_fail;
11690  }
11691  {
11692  if ( _n_dims( args(0) ) > 2 )
11693  {
11694  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11695  }
11696  temp1 = args(0).matrix_value();
11697  arg1 = &temp1( 0, 0 );
11698  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11699  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11700  }
11701  ecode4 = SWIG_AsVal_int(args(1), &val4);
11702  if (!SWIG_IsOK(ecode4)) {
11703  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11704  }
11705  arg4 = static_cast< PLINT >(val4);
11706  ecode5 = SWIG_AsVal_int(args(2), &val5);
11707  if (!SWIG_IsOK(ecode5)) {
11708  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11709  }
11710  arg5 = static_cast< PLINT >(val5);
11711  ecode6 = SWIG_AsVal_int(args(3), &val6);
11712  if (!SWIG_IsOK(ecode6)) {
11713  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11714  }
11715  arg6 = static_cast< PLINT >(val6);
11716  ecode7 = SWIG_AsVal_int(args(4), &val7);
11717  if (!SWIG_IsOK(ecode7)) {
11718  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11719  }
11720  arg7 = static_cast< PLINT >(val7);
11721  {
11722  if ( _n_dims( args(5) ) > 1 )
11723  {
11724  error( "argument must be a scalar or vector" ); SWIG_fail;
11725  }
11726  temp8 = args(5).matrix_value();
11727  arg8 = &temp8( 0, 0 );
11728  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11729  }
11730  {
11731  if ( _n_dims( args(6) ) > 1 )
11732  {
11733  error( "argument must be a scalar or vector" ); SWIG_fail;
11734  }
11735  if ( _dim( args(6), 0 ) != Xlen )
11736  {
11737  error( "argument vectors must be same length" ); SWIG_fail;
11738  }
11739  temp10 = args(6).matrix_value();
11740  arg10 = &temp10( 0, 0 );
11741  }
11742  {
11743  if ( _n_dims( args(7) ) > 1 )
11744  {
11745  error( "argument must be a scalar or vector" ); SWIG_fail;
11746  }
11747  if ( _dim( args(7), 0 ) != Ylen )
11748  {
11749  error( "argument vectors must be same length" ); SWIG_fail;
11750  }
11751  temp11 = args(7).matrix_value();
11752  arg11 = &temp11( 0, 0 );
11753  }
11754  my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11755  _outv = octave_value();
11756  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11757  {
11758 
11759  }
11760  {
11761 
11762  }
11763  {
11764 
11765  }
11766  {
11767 
11768  }
11769  return _out;
11770  fail:
11771  {
11772 
11773  }
11774  {
11775 
11776  }
11777  {
11778 
11779  }
11780  {
11781 
11782  }
11783  return octave_value_list();
11784  }
11785  catch(...) {
11786  {
11787 
11788  }
11789  {
11790 
11791  }
11792  {
11793 
11794  }
11795  {
11796 
11797  }
11798  throw;
11799  }
11800 }
11801 
11802 
11803 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
11804  PLFLT *arg1 = (PLFLT *) 0 ;
11805  PLINT arg2 ;
11806  PLINT arg3 ;
11807  PLINT arg4 ;
11808  PLINT arg5 ;
11809  PLINT arg6 ;
11810  PLINT arg7 ;
11811  PLFLT *arg8 = (PLFLT *) 0 ;
11812  PLINT arg9 ;
11813  PLFLT *arg10 = (PLFLT *) 0 ;
11814  PLFLT *arg11 = (PLFLT *) 0 ;
11815  Matrix temp1 ;
11816  int val4 ;
11817  int ecode4 = 0 ;
11818  int val5 ;
11819  int ecode5 = 0 ;
11820  int val6 ;
11821  int ecode6 = 0 ;
11822  int val7 ;
11823  int ecode7 = 0 ;
11824  Matrix temp8 ;
11825  Matrix temp10 ;
11826  Matrix temp11 ;
11827  octave_value_list _out;
11828  octave_value_list *_outp=&_out;
11829  octave_value _outv;
11830 
11831  try {
11832  if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11833  SWIG_fail;
11834  }
11835  {
11836  if ( _n_dims( args(0) ) > 2 )
11837  {
11838  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11839  }
11840  temp1 = args(0).matrix_value();
11841  arg1 = &temp1( 0, 0 );
11842  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11843  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11844  }
11845  ecode4 = SWIG_AsVal_int(args(1), &val4);
11846  if (!SWIG_IsOK(ecode4)) {
11847  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11848  }
11849  arg4 = static_cast< PLINT >(val4);
11850  ecode5 = SWIG_AsVal_int(args(2), &val5);
11851  if (!SWIG_IsOK(ecode5)) {
11852  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11853  }
11854  arg5 = static_cast< PLINT >(val5);
11855  ecode6 = SWIG_AsVal_int(args(3), &val6);
11856  if (!SWIG_IsOK(ecode6)) {
11857  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
11858  }
11859  arg6 = static_cast< PLINT >(val6);
11860  ecode7 = SWIG_AsVal_int(args(4), &val7);
11861  if (!SWIG_IsOK(ecode7)) {
11862  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
11863  }
11864  arg7 = static_cast< PLINT >(val7);
11865  {
11866  if ( _n_dims( args(5) ) > 1 )
11867  {
11868  error( "argument must be a scalar or vector" ); SWIG_fail;
11869  }
11870  temp8 = args(5).matrix_value();
11871  arg8 = &temp8( 0, 0 );
11872  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11873  }
11874  {
11875  if ( _n_dims( args(6) ) > 2 )
11876  {
11877  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11878  }
11879  if ( _dim( args(6), 0 ) != Xlen )
11880  {
11881  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11882  }
11883  if ( _dim( args(6), 1 ) != Ylen )
11884  {
11885  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11886  }
11887  temp10 = args(6).matrix_value();
11888  arg10 = &temp10( 0, 0 );
11889  }
11890  {
11891  if ( _n_dims( args(7) ) > 2 )
11892  {
11893  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11894  }
11895  if ( _dim( args(7), 0 ) != Xlen )
11896  {
11897  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11898  }
11899  if ( _dim( args(7), 1 ) != Ylen )
11900  {
11901  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11902  }
11903  temp11 = args(7).matrix_value();
11904  arg11 = &temp11( 0, 0 );
11905  }
11906  my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11907  _outv = octave_value();
11908  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11909  {
11910 
11911  }
11912  {
11913 
11914  }
11915  {
11916 
11917  }
11918  {
11919 
11920  }
11921  return _out;
11922  fail:
11923  {
11924 
11925  }
11926  {
11927 
11928  }
11929  {
11930 
11931  }
11932  {
11933 
11934  }
11935  return octave_value_list();
11936  }
11937  catch(...) {
11938  {
11939 
11940  }
11941  {
11942 
11943  }
11944  {
11945 
11946  }
11947  {
11948 
11949  }
11950  throw;
11951  }
11952 }
11953 
11954 
11955 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
11956  PLFLT *arg1 = (PLFLT *) 0 ;
11957  PLINT arg2 ;
11958  PLINT arg3 ;
11959  PLINT arg4 ;
11960  PLINT arg5 ;
11961  PLINT arg6 ;
11962  PLINT arg7 ;
11963  PLFLT *arg8 = (PLFLT *) 0 ;
11964  PLINT arg9 ;
11965  PLFLT *arg10 = (PLFLT *) 0 ;
11966  PLFLT *arg11 = (PLFLT *) 0 ;
11967  Matrix temp1 ;
11968  int val4 ;
11969  int ecode4 = 0 ;
11970  int val5 ;
11971  int ecode5 = 0 ;
11972  int val6 ;
11973  int ecode6 = 0 ;
11974  int val7 ;
11975  int ecode7 = 0 ;
11976  Matrix temp8 ;
11977  Matrix temp10 ;
11978  Matrix temp11 ;
11979  octave_value_list _out;
11980  octave_value_list *_outp=&_out;
11981  octave_value _outv;
11982 
11983  try {
11984  if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
11985  SWIG_fail;
11986  }
11987  {
11988  if ( _n_dims( args(0) ) > 2 )
11989  {
11990  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11991  }
11992  temp1 = args(0).matrix_value();
11993  arg1 = &temp1( 0, 0 );
11994  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11995  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11996  }
11997  ecode4 = SWIG_AsVal_int(args(1), &val4);
11998  if (!SWIG_IsOK(ecode4)) {
11999  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
12000  }
12001  arg4 = static_cast< PLINT >(val4);
12002  ecode5 = SWIG_AsVal_int(args(2), &val5);
12003  if (!SWIG_IsOK(ecode5)) {
12004  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
12005  }
12006  arg5 = static_cast< PLINT >(val5);
12007  ecode6 = SWIG_AsVal_int(args(3), &val6);
12008  if (!SWIG_IsOK(ecode6)) {
12009  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
12010  }
12011  arg6 = static_cast< PLINT >(val6);
12012  ecode7 = SWIG_AsVal_int(args(4), &val7);
12013  if (!SWIG_IsOK(ecode7)) {
12014  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
12015  }
12016  arg7 = static_cast< PLINT >(val7);
12017  {
12018  if ( _n_dims( args(5) ) > 1 )
12019  {
12020  error( "argument must be a scalar or vector" ); SWIG_fail;
12021  }
12022  temp8 = args(5).matrix_value();
12023  arg8 = &temp8( 0, 0 );
12024  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12025  }
12026  {
12027  if ( _n_dims( args(6) ) > 2 )
12028  {
12029  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12030  }
12031  if ( _dim( args(6), 0 ) != Xlen )
12032  {
12033  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12034  }
12035  if ( _dim( args(6), 1 ) != Ylen )
12036  {
12037  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12038  }
12039  temp10 = args(6).matrix_value();
12040  arg10 = &temp10( 0, 0 );
12041  }
12042  {
12043  if ( _n_dims( args(7) ) > 2 )
12044  {
12045  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12046  }
12047  if ( _dim( args(7), 0 ) != Xlen )
12048  {
12049  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12050  }
12051  if ( _dim( args(7), 1 ) != Ylen )
12052  {
12053  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12054  }
12055  temp11 = args(7).matrix_value();
12056  arg11 = &temp11( 0, 0 );
12057  }
12058  my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12059  _outv = octave_value();
12060  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12061  {
12062 
12063  }
12064  {
12065 
12066  }
12067  {
12068 
12069  }
12070  {
12071 
12072  }
12073  return _out;
12074  fail:
12075  {
12076 
12077  }
12078  {
12079 
12080  }
12081  {
12082 
12083  }
12084  {
12085 
12086  }
12087  return octave_value_list();
12088  }
12089  catch(...) {
12090  {
12091 
12092  }
12093  {
12094 
12095  }
12096  {
12097 
12098  }
12099  {
12100 
12101  }
12102  throw;
12103  }
12104 }
12105 
12106 
12108  PLFLT *arg1 = (PLFLT *) 0 ;
12109  PLFLT *arg2 = (PLFLT *) 0 ;
12110  PLFLT *arg3 = (PLFLT *) 0 ;
12111  PLINT arg4 ;
12112  PLFLT *arg5 = (PLFLT *) 0 ;
12113  PLINT arg6 ;
12114  PLFLT *arg7 = (PLFLT *) 0 ;
12115  PLINT arg8 ;
12116  PLFLT *arg9 = (PLFLT *) 0 ;
12117  PLINT arg10 ;
12118  PLFLT arg11 ;
12119  Matrix temp1 ;
12120  Matrix temp2 ;
12121  Matrix temp3 ;
12122  Matrix temp5 ;
12123  Matrix temp7 ;
12124  octave_value_list retval7 ;
12125  int val10 ;
12126  int ecode10 = 0 ;
12127  double val11 ;
12128  int ecode11 = 0 ;
12129  octave_value_list _out;
12130  octave_value_list *_outp=&_out;
12131  octave_value _outv;
12132 
12133  try {
12134  if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
12135  SWIG_fail;
12136  }
12137  {
12138  if ( _n_dims( args(0) ) > 1 )
12139  {
12140  error( "argument must be a scalar or vector" ); SWIG_fail;
12141  }
12142  Alen = (PLINT) ( _dim( args(0), 0 ) );
12143  temp1 = args(0).matrix_value();
12144  arg1 = &temp1( 0, 0 );
12145  }
12146  {
12147  if ( _n_dims( args(1) ) > 1 )
12148  {
12149  error( "argument must be a scalar or vector" ); SWIG_fail;
12150  }
12151  if ( _dim( args(1), 0 ) != Alen )
12152  {
12153  error( "argument vectors must be same length" ); SWIG_fail;
12154  }
12155  temp2 = args(1).matrix_value();
12156  arg2 = &temp2( 0, 0 );
12157  }
12158  {
12159  if ( _n_dims( args(2) ) > 1 )
12160  {
12161  error( "argument must be a scalar or vector" ); SWIG_fail;
12162  }
12163  if ( _dim( args(2), 0 ) != Alen )
12164  {
12165  error( "argument vectors must be same length" ); SWIG_fail;
12166  }
12167  temp3 = args(2).matrix_value();
12168  arg3 = &temp3( 0, 0 );
12169  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12170  }
12171  {
12172  if ( _n_dims( args(3) ) > 1 )
12173  {
12174  error( "argument must be a scalar or vector" ); SWIG_fail;
12175  }
12176  temp5 = args(3).matrix_value();
12177  arg5 = &temp5( 0, 0 );
12178  arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12179  }
12180  {
12181  if ( _n_dims( args(4) ) > 1 )
12182  {
12183  error( "argument must be a scalar or vector" ); SWIG_fail;
12184  }
12185  temp7 = args(4).matrix_value();
12186  arg7 = &temp7( 0, 0 );
12187  arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12188  retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12189  arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12190  }
12191  ecode10 = SWIG_AsVal_int(args(5), &val10);
12192  if (!SWIG_IsOK(ecode10)) {
12193  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12194  }
12195  arg10 = static_cast< PLINT >(val10);
12196  ecode11 = SWIG_AsVal_double(args(6), &val11);
12197  if (!SWIG_IsOK(ecode11)) {
12198  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12199  }
12200  arg11 = static_cast< PLFLT >(val11);
12201  my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12202  _outv = octave_value();
12203  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12204  {
12205  _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
12206  }
12207  {
12208 
12209  }
12210  {
12211 
12212  }
12213  {
12214 
12215  }
12216  {
12217 
12218  }
12219  {
12220 
12221  }
12222  return _out;
12223  fail:
12224  {
12225 
12226  }
12227  {
12228 
12229  }
12230  {
12231 
12232  }
12233  {
12234 
12235  }
12236  {
12237 
12238  }
12239  return octave_value_list();
12240  }
12241  catch(...) {
12242  {
12243 
12244  }
12245  {
12246 
12247  }
12248  {
12249 
12250  }
12251  {
12252 
12253  }
12254  {
12255 
12256  }
12257  throw;
12258  }
12259 }
12260 
12261 
12263  PLFLT *arg1 = (PLFLT *) 0 ;
12264  PLFLT *arg2 = (PLFLT *) 0 ;
12265  PLFLT *arg3 = (PLFLT *) 0 ;
12266  PLINT arg4 ;
12267  PLINT arg5 ;
12268  PLINT arg6 ;
12269  Matrix temp1 ;
12270  Matrix temp2 ;
12271  Matrix temp3 ;
12272  int val6 ;
12273  int ecode6 = 0 ;
12274  octave_value_list _out;
12275  octave_value_list *_outp=&_out;
12276  octave_value _outv;
12277 
12278  try {
12279  if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12280  SWIG_fail;
12281  }
12282  {
12283  if ( _n_dims( args(0) ) > 1 )
12284  {
12285  error( "argument must be a scalar or vector" ); SWIG_fail;
12286  }
12287  temp1 = args(0).matrix_value();
12288  arg1 = &temp1( 0, 0 );
12289  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12290  }
12291  {
12292  if ( _n_dims( args(1) ) > 1 )
12293  {
12294  error( "argument must be a scalar or vector" ); SWIG_fail;
12295  }
12296  temp2 = args(1).matrix_value();
12297  arg2 = &temp2( 0, 0 );
12298  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12299  }
12300  {
12301  if ( _n_dims( args(2) ) > 2 )
12302  {
12303  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12304  }
12305  if ( _dim( args(2), 0 ) != Xlen )
12306  {
12307  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12308  }
12309  if ( _dim( args(2), 1 ) != Ylen )
12310  {
12311  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12312  }
12313  temp3 = args(2).matrix_value();
12314  arg3 = &temp3( 0, 0 );
12315  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12316  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12317  }
12318  ecode6 = SWIG_AsVal_int(args(3), &val6);
12319  if (!SWIG_IsOK(ecode6)) {
12320  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12321  }
12322  arg6 = static_cast< PLINT >(val6);
12323  my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12324  _outv = octave_value();
12325  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12326  {
12327 
12328  }
12329  {
12330 
12331  }
12332  {
12333 
12334  }
12335  return _out;
12336  fail:
12337  {
12338 
12339  }
12340  {
12341 
12342  }
12343  {
12344 
12345  }
12346  return octave_value_list();
12347  }
12348  catch(...) {
12349  {
12350 
12351  }
12352  {
12353 
12354  }
12355  {
12356 
12357  }
12358  throw;
12359  }
12360 }
12361 
12362 
12364  PLFLT *arg1 = (PLFLT *) 0 ;
12365  PLFLT *arg2 = (PLFLT *) 0 ;
12366  PLFLT *arg3 = (PLFLT *) 0 ;
12367  PLINT arg4 ;
12368  PLINT arg5 ;
12369  PLINT arg6 ;
12370  PLFLT *arg7 = (PLFLT *) 0 ;
12371  PLINT arg8 ;
12372  Matrix temp1 ;
12373  Matrix temp2 ;
12374  Matrix temp3 ;
12375  int val6 ;
12376  int ecode6 = 0 ;
12377  Matrix temp7 ;
12378  octave_value_list _out;
12379  octave_value_list *_outp=&_out;
12380  octave_value _outv;
12381 
12382  try {
12383  if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12384  SWIG_fail;
12385  }
12386  {
12387  if ( _n_dims( args(0) ) > 1 )
12388  {
12389  error( "argument must be a scalar or vector" ); SWIG_fail;
12390  }
12391  temp1 = args(0).matrix_value();
12392  arg1 = &temp1( 0, 0 );
12393  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12394  }
12395  {
12396  if ( _n_dims( args(1) ) > 1 )
12397  {
12398  error( "argument must be a scalar or vector" ); SWIG_fail;
12399  }
12400  temp2 = args(1).matrix_value();
12401  arg2 = &temp2( 0, 0 );
12402  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12403  }
12404  {
12405  if ( _n_dims( args(2) ) > 2 )
12406  {
12407  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12408  }
12409  if ( _dim( args(2), 0 ) != Xlen )
12410  {
12411  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12412  }
12413  if ( _dim( args(2), 1 ) != Ylen )
12414  {
12415  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12416  }
12417  temp3 = args(2).matrix_value();
12418  arg3 = &temp3( 0, 0 );
12419  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12420  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12421  }
12422  ecode6 = SWIG_AsVal_int(args(3), &val6);
12423  if (!SWIG_IsOK(ecode6)) {
12424  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12425  }
12426  arg6 = static_cast< PLINT >(val6);
12427  {
12428  if ( _n_dims( args(4) ) > 1 )
12429  {
12430  error( "argument must be a scalar or vector" ); SWIG_fail;
12431  }
12432  temp7 = args(4).matrix_value();
12433  arg7 = &temp7( 0, 0 );
12434  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12435  }
12436  my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12437  _outv = octave_value();
12438  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12439  {
12440 
12441  }
12442  {
12443 
12444  }
12445  {
12446 
12447  }
12448  {
12449 
12450  }
12451  return _out;
12452  fail:
12453  {
12454 
12455  }
12456  {
12457 
12458  }
12459  {
12460 
12461  }
12462  {
12463 
12464  }
12465  return octave_value_list();
12466  }
12467  catch(...) {
12468  {
12469 
12470  }
12471  {
12472 
12473  }
12474  {
12475 
12476  }
12477  {
12478 
12479  }
12480  throw;
12481  }
12482 }
12483 
12484 
12486  PLFLT *arg1 = (PLFLT *) 0 ;
12487  PLFLT *arg2 = (PLFLT *) 0 ;
12488  PLFLT *arg3 = (PLFLT *) 0 ;
12489  PLINT arg4 ;
12490  PLINT arg5 ;
12491  PLINT arg6 ;
12492  PLBOOL arg7 ;
12493  Matrix temp1 ;
12494  Matrix temp2 ;
12495  Matrix temp3 ;
12496  int val6 ;
12497  int ecode6 = 0 ;
12498  int val7 ;
12499  int ecode7 = 0 ;
12500  octave_value_list _out;
12501  octave_value_list *_outp=&_out;
12502  octave_value _outv;
12503 
12504  try {
12505  if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12506  SWIG_fail;
12507  }
12508  {
12509  if ( _n_dims( args(0) ) > 1 )
12510  {
12511  error( "argument must be a scalar or vector" ); SWIG_fail;
12512  }
12513  temp1 = args(0).matrix_value();
12514  arg1 = &temp1( 0, 0 );
12515  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12516  }
12517  {
12518  if ( _n_dims( args(1) ) > 1 )
12519  {
12520  error( "argument must be a scalar or vector" ); SWIG_fail;
12521  }
12522  temp2 = args(1).matrix_value();
12523  arg2 = &temp2( 0, 0 );
12524  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12525  }
12526  {
12527  if ( _n_dims( args(2) ) > 2 )
12528  {
12529  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12530  }
12531  if ( _dim( args(2), 0 ) != Xlen )
12532  {
12533  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12534  }
12535  if ( _dim( args(2), 1 ) != Ylen )
12536  {
12537  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12538  }
12539  temp3 = args(2).matrix_value();
12540  arg3 = &temp3( 0, 0 );
12541  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12542  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12543  }
12544  ecode6 = SWIG_AsVal_int(args(3), &val6);
12545  if (!SWIG_IsOK(ecode6)) {
12546  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12547  }
12548  arg6 = static_cast< PLINT >(val6);
12549  ecode7 = SWIG_AsVal_int(args(4), &val7);
12550  if (!SWIG_IsOK(ecode7)) {
12551  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12552  }
12553  arg7 = static_cast< PLBOOL >(val7);
12554  my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12555  _outv = octave_value();
12556  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12557  {
12558 
12559  }
12560  {
12561 
12562  }
12563  {
12564 
12565  }
12566  return _out;
12567  fail:
12568  {
12569 
12570  }
12571  {
12572 
12573  }
12574  {
12575 
12576  }
12577  return octave_value_list();
12578  }
12579  catch(...) {
12580  {
12581 
12582  }
12583  {
12584 
12585  }
12586  {
12587 
12588  }
12589  throw;
12590  }
12591 }
12592 
12593 
12595  PLFLT *arg1 = (PLFLT *) 0 ;
12596  PLFLT *arg2 = (PLFLT *) 0 ;
12597  PLFLT *arg3 = (PLFLT *) 0 ;
12598  PLINT arg4 ;
12599  PLINT arg5 ;
12600  PLINT arg6 ;
12601  PLFLT *arg7 = (PLFLT *) 0 ;
12602  PLINT arg8 ;
12603  Matrix temp1 ;
12604  Matrix temp2 ;
12605  Matrix temp3 ;
12606  int val6 ;
12607  int ecode6 = 0 ;
12608  Matrix temp7 ;
12609  octave_value_list _out;
12610  octave_value_list *_outp=&_out;
12611  octave_value _outv;
12612 
12613  try {
12614  if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12615  SWIG_fail;
12616  }
12617  {
12618  if ( _n_dims( args(0) ) > 1 )
12619  {
12620  error( "argument must be a scalar or vector" ); SWIG_fail;
12621  }
12622  temp1 = args(0).matrix_value();
12623  arg1 = &temp1( 0, 0 );
12624  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12625  }
12626  {
12627  if ( _n_dims( args(1) ) > 1 )
12628  {
12629  error( "argument must be a scalar or vector" ); SWIG_fail;
12630  }
12631  temp2 = args(1).matrix_value();
12632  arg2 = &temp2( 0, 0 );
12633  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12634  }
12635  {
12636  if ( _n_dims( args(2) ) > 2 )
12637  {
12638  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12639  }
12640  if ( _dim( args(2), 0 ) != Xlen )
12641  {
12642  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12643  }
12644  if ( _dim( args(2), 1 ) != Ylen )
12645  {
12646  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12647  }
12648  temp3 = args(2).matrix_value();
12649  arg3 = &temp3( 0, 0 );
12650  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12651  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12652  }
12653  ecode6 = SWIG_AsVal_int(args(3), &val6);
12654  if (!SWIG_IsOK(ecode6)) {
12655  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12656  }
12657  arg6 = static_cast< PLINT >(val6);
12658  {
12659  if ( _n_dims( args(4) ) > 1 )
12660  {
12661  error( "argument must be a scalar or vector" ); SWIG_fail;
12662  }
12663  temp7 = args(4).matrix_value();
12664  arg7 = &temp7( 0, 0 );
12665  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12666  }
12667  my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12668  _outv = octave_value();
12669  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12670  {
12671 
12672  }
12673  {
12674 
12675  }
12676  {
12677 
12678  }
12679  {
12680 
12681  }
12682  return _out;
12683  fail:
12684  {
12685 
12686  }
12687  {
12688 
12689  }
12690  {
12691 
12692  }
12693  {
12694 
12695  }
12696  return octave_value_list();
12697  }
12698  catch(...) {
12699  {
12700 
12701  }
12702  {
12703 
12704  }
12705  {
12706 
12707  }
12708  {
12709 
12710  }
12711  throw;
12712  }
12713 }
12714 
12715 
12717  PLFLT *arg1 = (PLFLT *) 0 ;
12718  PLFLT *arg2 = (PLFLT *) 0 ;
12719  PLFLT *arg3 = (PLFLT *) 0 ;
12720  PLINT arg4 ;
12721  PLINT arg5 ;
12722  PLINT arg6 ;
12723  PLFLT *arg7 = (PLFLT *) 0 ;
12724  PLINT arg8 ;
12725  PLINT arg9 ;
12726  PLINT arg10 ;
12727  PLINT *arg11 = (PLINT *) 0 ;
12728  PLINT *arg12 = (PLINT *) 0 ;
12729  Matrix temp1 ;
12730  Matrix temp2 ;
12731  Matrix temp3 ;
12732  int val6 ;
12733  int ecode6 = 0 ;
12734  Matrix temp7 ;
12735  int val9 ;
12736  int ecode9 = 0 ;
12737  Matrix temp10 ;
12738  Matrix temp12 ;
12739  octave_value_list _out;
12740  octave_value_list *_outp=&_out;
12741  octave_value _outv;
12742 
12743  try {
12744  if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12745  SWIG_fail;
12746  }
12747  {
12748  if ( _n_dims( args(0) ) > 1 )
12749  {
12750  error( "argument must be a scalar or vector" ); SWIG_fail;
12751  }
12752  temp1 = args(0).matrix_value();
12753  arg1 = &temp1( 0, 0 );
12754  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12755  }
12756  {
12757  if ( _n_dims( args(1) ) > 1 )
12758  {
12759  error( "argument must be a scalar or vector" ); SWIG_fail;
12760  }
12761  temp2 = args(1).matrix_value();
12762  arg2 = &temp2( 0, 0 );
12763  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12764  }
12765  {
12766  if ( _n_dims( args(2) ) > 2 )
12767  {
12768  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12769  }
12770  if ( _dim( args(2), 0 ) != Xlen )
12771  {
12772  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12773  }
12774  if ( _dim( args(2), 1 ) != Ylen )
12775  {
12776  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12777  }
12778  temp3 = args(2).matrix_value();
12779  arg3 = &temp3( 0, 0 );
12780  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12781  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12782  }
12783  ecode6 = SWIG_AsVal_int(args(3), &val6);
12784  if (!SWIG_IsOK(ecode6)) {
12785  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
12786  }
12787  arg6 = static_cast< PLINT >(val6);
12788  {
12789  if ( _n_dims( args(4) ) > 1 )
12790  {
12791  error( "argument must be a scalar or vector" ); SWIG_fail;
12792  }
12793  temp7 = args(4).matrix_value();
12794  arg7 = &temp7( 0, 0 );
12795  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12796  }
12797  ecode9 = SWIG_AsVal_int(args(5), &val9);
12798  if (!SWIG_IsOK(ecode9)) {
12799  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
12800  }
12801  arg9 = static_cast< PLINT >(val9);
12802  {
12803  if ( _n_dims( args(6) ) > 1 )
12804  {
12805  error( "argument must be a scalar or vector" ); SWIG_fail;
12806  }
12807  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12808  arg11 = new PLINT[Alen];
12809  temp10 = args(6).matrix_value();
12810  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12811  }
12812  {
12813  if ( _n_dims( args(7) ) > 1 )
12814  {
12815  error( "argument must be a scalar or vector" ); SWIG_fail;
12816  }
12817  if ( _dim( args(7), 0 ) != Alen )
12818  {
12819  error( "argument vectors must be same length" ); SWIG_fail;
12820  }
12821  temp12 = args(7).matrix_value();
12822  arg12 = new PLINT[Alen];
12823  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12824  }
12825  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);
12826  _outv = octave_value();
12827  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12828  {
12829 
12830  }
12831  {
12832 
12833  }
12834  {
12835 
12836  }
12837  {
12838 
12839  }
12840  {
12841  delete [] arg11;
12842  }
12843  {
12844  delete [] arg12;
12845  }
12846  return _out;
12847  fail:
12848  {
12849 
12850  }
12851  {
12852 
12853  }
12854  {
12855 
12856  }
12857  {
12858 
12859  }
12860  {
12861  delete [] arg11;
12862  }
12863  {
12864  delete [] arg12;
12865  }
12866  return octave_value_list();
12867  }
12868  catch(...) {
12869  {
12870 
12871  }
12872  {
12873 
12874  }
12875  {
12876 
12877  }
12878  {
12879 
12880  }
12881  {
12882  delete [] arg11;
12883  }
12884  {
12885  delete [] arg12;
12886  }
12887  throw;
12888  }
12889 }
12890 
12891 
12893  PLFLT *arg1 = (PLFLT *) 0 ;
12894  PLFLT *arg2 = (PLFLT *) 0 ;
12895  PLFLT *arg3 = (PLFLT *) 0 ;
12896  PLINT arg4 ;
12897  PLINT arg5 ;
12898  PLINT arg6 ;
12899  PLFLT *arg7 = (PLFLT *) 0 ;
12900  PLINT arg8 ;
12901  Matrix temp1 ;
12902  Matrix temp2 ;
12903  Matrix temp3 ;
12904  int val6 ;
12905  int ecode6 = 0 ;
12906  Matrix temp7 ;
12907  octave_value_list _out;
12908  octave_value_list *_outp=&_out;
12909  octave_value _outv;
12910 
12911  try {
12912  if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
12913  SWIG_fail;
12914  }
12915  {
12916  if ( _n_dims( args(0) ) > 1 )
12917  {
12918  error( "argument must be a scalar or vector" ); SWIG_fail;
12919  }
12920  temp1 = args(0).matrix_value();
12921  arg1 = &temp1( 0, 0 );
12922  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12923  }
12924  {
12925  if ( _n_dims( args(1) ) > 1 )
12926  {
12927  error( "argument must be a scalar or vector" ); SWIG_fail;
12928  }
12929  temp2 = args(1).matrix_value();
12930  arg2 = &temp2( 0, 0 );
12931  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12932  }
12933  {
12934  if ( _n_dims( args(2) ) > 2 )
12935  {
12936  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12937  }
12938  if ( _dim( args(2), 0 ) != Xlen )
12939  {
12940  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12941  }
12942  if ( _dim( args(2), 1 ) != Ylen )
12943  {
12944  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12945  }
12946  temp3 = args(2).matrix_value();
12947  arg3 = &temp3( 0, 0 );
12948  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12949  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12950  }
12951  ecode6 = SWIG_AsVal_int(args(3), &val6);
12952  if (!SWIG_IsOK(ecode6)) {
12953  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
12954  }
12955  arg6 = static_cast< PLINT >(val6);
12956  {
12957  if ( _n_dims( args(4) ) > 1 )
12958  {
12959  error( "argument must be a scalar or vector" ); SWIG_fail;
12960  }
12961  temp7 = args(4).matrix_value();
12962  arg7 = &temp7( 0, 0 );
12963  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12964  }
12965  my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12966  _outv = octave_value();
12967  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12968  {
12969 
12970  }
12971  {
12972 
12973  }
12974  {
12975 
12976  }
12977  {
12978 
12979  }
12980  return _out;
12981  fail:
12982  {
12983 
12984  }
12985  {
12986 
12987  }
12988  {
12989 
12990  }
12991  {
12992 
12993  }
12994  return octave_value_list();
12995  }
12996  catch(...) {
12997  {
12998 
12999  }
13000  {
13001 
13002  }
13003  {
13004 
13005  }
13006  {
13007 
13008  }
13009  throw;
13010  }
13011 }
13012 
13013 
13015  PLFLT *arg1 = (PLFLT *) 0 ;
13016  PLFLT *arg2 = (PLFLT *) 0 ;
13017  PLFLT *arg3 = (PLFLT *) 0 ;
13018  PLINT arg4 ;
13019  PLINT arg5 ;
13020  PLINT arg6 ;
13021  PLFLT *arg7 = (PLFLT *) 0 ;
13022  PLINT arg8 ;
13023  PLINT arg9 ;
13024  PLINT arg10 ;
13025  PLINT *arg11 = (PLINT *) 0 ;
13026  PLINT *arg12 = (PLINT *) 0 ;
13027  Matrix temp1 ;
13028  Matrix temp2 ;
13029  Matrix temp3 ;
13030  int val6 ;
13031  int ecode6 = 0 ;
13032  Matrix temp7 ;
13033  int val9 ;
13034  int ecode9 = 0 ;
13035  Matrix temp10 ;
13036  Matrix temp12 ;
13037  octave_value_list _out;
13038  octave_value_list *_outp=&_out;
13039  octave_value _outv;
13040 
13041  try {
13042  if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
13043  SWIG_fail;
13044  }
13045  {
13046  if ( _n_dims( args(0) ) > 1 )
13047  {
13048  error( "argument must be a scalar or vector" ); SWIG_fail;
13049  }
13050  temp1 = args(0).matrix_value();
13051  arg1 = &temp1( 0, 0 );
13052  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13053  }
13054  {
13055  if ( _n_dims( args(1) ) > 1 )
13056  {
13057  error( "argument must be a scalar or vector" ); SWIG_fail;
13058  }
13059  temp2 = args(1).matrix_value();
13060  arg2 = &temp2( 0, 0 );
13061  Ylen = (PLINT) ( _dim( args(1), 0 ) );
13062  }
13063  {
13064  if ( _n_dims( args(2) ) > 2 )
13065  {
13066  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13067  }
13068  if ( _dim( args(2), 0 ) != Xlen )
13069  {
13070  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13071  }
13072  if ( _dim( args(2), 1 ) != Ylen )
13073  {
13074  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13075  }
13076  temp3 = args(2).matrix_value();
13077  arg3 = &temp3( 0, 0 );
13078  arg4 = (PLINT) ( _dim( args(2), 0 ) );
13079  arg5 = (PLINT) ( _dim( args(2), 1 ) );
13080  }
13081  ecode6 = SWIG_AsVal_int(args(3), &val6);
13082  if (!SWIG_IsOK(ecode6)) {
13083  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
13084  }
13085  arg6 = static_cast< PLINT >(val6);
13086  {
13087  if ( _n_dims( args(4) ) > 1 )
13088  {
13089  error( "argument must be a scalar or vector" ); SWIG_fail;
13090  }
13091  temp7 = args(4).matrix_value();
13092  arg7 = &temp7( 0, 0 );
13093  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13094  }
13095  ecode9 = SWIG_AsVal_int(args(5), &val9);
13096  if (!SWIG_IsOK(ecode9)) {
13097  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
13098  }
13099  arg9 = static_cast< PLINT >(val9);
13100  {
13101  if ( _n_dims( args(6) ) > 1 )
13102  {
13103  error( "argument must be a scalar or vector" ); SWIG_fail;
13104  }
13105  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13106  arg11 = new PLINT[Alen];
13107  temp10 = args(6).matrix_value();
13108  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13109  }
13110  {
13111  if ( _n_dims( args(7) ) > 1 )
13112  {
13113  error( "argument must be a scalar or vector" ); SWIG_fail;
13114  }
13115  if ( _dim( args(7), 0 ) != Alen )
13116  {
13117  error( "argument vectors must be same length" ); SWIG_fail;
13118  }
13119  temp12 = args(7).matrix_value();
13120  arg12 = new PLINT[Alen];
13121  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13122  }
13123  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);
13124  _outv = octave_value();
13125  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13126  {
13127 
13128  }
13129  {
13130 
13131  }
13132  {
13133 
13134  }
13135  {
13136 
13137  }
13138  {
13139  delete [] arg11;
13140  }
13141  {
13142  delete [] arg12;
13143  }
13144  return _out;
13145  fail:
13146  {
13147 
13148  }
13149  {
13150 
13151  }
13152  {
13153 
13154  }
13155  {
13156 
13157  }
13158  {
13159  delete [] arg11;
13160  }
13161  {
13162  delete [] arg12;
13163  }
13164  return octave_value_list();
13165  }
13166  catch(...) {
13167  {
13168 
13169  }
13170  {
13171 
13172  }
13173  {
13174 
13175  }
13176  {
13177 
13178  }
13179  {
13180  delete [] arg11;
13181  }
13182  {
13183  delete [] arg12;
13184  }
13185  throw;
13186  }
13187 }
13188 
13189 
13191  PLFLT *arg1 = (PLFLT *) 0 ;
13192  PLINT arg2 ;
13193  PLINT arg3 ;
13194  PLFLT *arg4 = (PLFLT *) 0 ;
13195  PLFLT arg5 ;
13196  PLFLT arg6 ;
13197  PLFLT arg7 ;
13198  PLFLT arg8 ;
13199  PLFLT arg9 ;
13200  PLFLT arg10 ;
13201  PLINT arg11 ;
13202  PLFLT arg12 ;
13203  PLINT arg13 ;
13204  PLINT arg14 ;
13205  PLINT arg15 ;
13206  PLINT arg16 ;
13207  PLINT arg17 ;
13208  PLBOOL arg18 ;
13209  PLFLT *arg19 = (PLFLT *) 0 ;
13210  Matrix temp1 ;
13211  Matrix temp4 ;
13212  double val5 ;
13213  int ecode5 = 0 ;
13214  double val6 ;
13215  int ecode6 = 0 ;
13216  double val7 ;
13217  int ecode7 = 0 ;
13218  double val8 ;
13219  int ecode8 = 0 ;
13220  double val9 ;
13221  int ecode9 = 0 ;
13222  double val10 ;
13223  int ecode10 = 0 ;
13224  int val11 ;
13225  int ecode11 = 0 ;
13226  double val12 ;
13227  int ecode12 = 0 ;
13228  int val13 ;
13229  int ecode13 = 0 ;
13230  int val14 ;
13231  int ecode14 = 0 ;
13232  int val15 ;
13233  int ecode15 = 0 ;
13234  int val16 ;
13235  int ecode16 = 0 ;
13236  int val17 ;
13237  int ecode17 = 0 ;
13238  int val18 ;
13239  int ecode18 = 0 ;
13240  Matrix temp19 ;
13241  octave_value_list _out;
13242  octave_value_list *_outp=&_out;
13243  octave_value _outv;
13244 
13245  try {
13246  if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
13247  SWIG_fail;
13248  }
13249  {
13250  if ( _n_dims( args(0) ) > 2 )
13251  {
13252  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13253  }
13254  temp1 = args(0).matrix_value();
13255  arg1 = &temp1( 0, 0 );
13256  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13257  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13258  }
13259  {
13260  if ( _n_dims( args(1) ) > 1 )
13261  {
13262  error( "argument must be a scalar or vector" ); SWIG_fail;
13263  }
13264  Alen = (PLINT) ( _dim( args(1), 0 ) );
13265  temp4 = args(1).matrix_value();
13266  arg4 = &temp4( 0, 0 );
13267  }
13268  ecode5 = SWIG_AsVal_double(args(2), &val5);
13269  if (!SWIG_IsOK(ecode5)) {
13270  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
13271  }
13272  arg5 = static_cast< PLFLT >(val5);
13273  ecode6 = SWIG_AsVal_double(args(3), &val6);
13274  if (!SWIG_IsOK(ecode6)) {
13275  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
13276  }
13277  arg6 = static_cast< PLFLT >(val6);
13278  ecode7 = SWIG_AsVal_double(args(4), &val7);
13279  if (!SWIG_IsOK(ecode7)) {
13280  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
13281  }
13282  arg7 = static_cast< PLFLT >(val7);
13283  ecode8 = SWIG_AsVal_double(args(5), &val8);
13284  if (!SWIG_IsOK(ecode8)) {
13285  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
13286  }
13287  arg8 = static_cast< PLFLT >(val8);
13288  ecode9 = SWIG_AsVal_double(args(6), &val9);
13289  if (!SWIG_IsOK(ecode9)) {
13290  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
13291  }
13292  arg9 = static_cast< PLFLT >(val9);
13293  ecode10 = SWIG_AsVal_double(args(7), &val10);
13294  if (!SWIG_IsOK(ecode10)) {
13295  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
13296  }
13297  arg10 = static_cast< PLFLT >(val10);
13298  ecode11 = SWIG_AsVal_int(args(8), &val11);
13299  if (!SWIG_IsOK(ecode11)) {
13300  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13301  }
13302  arg11 = static_cast< PLINT >(val11);
13303  ecode12 = SWIG_AsVal_double(args(9), &val12);
13304  if (!SWIG_IsOK(ecode12)) {
13305  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13306  }
13307  arg12 = static_cast< PLFLT >(val12);
13308  ecode13 = SWIG_AsVal_int(args(10), &val13);
13309  if (!SWIG_IsOK(ecode13)) {
13310  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13311  }
13312  arg13 = static_cast< PLINT >(val13);
13313  ecode14 = SWIG_AsVal_int(args(11), &val14);
13314  if (!SWIG_IsOK(ecode14)) {
13315  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13316  }
13317  arg14 = static_cast< PLINT >(val14);
13318  ecode15 = SWIG_AsVal_int(args(12), &val15);
13319  if (!SWIG_IsOK(ecode15)) {
13320  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13321  }
13322  arg15 = static_cast< PLINT >(val15);
13323  ecode16 = SWIG_AsVal_int(args(13), &val16);
13324  if (!SWIG_IsOK(ecode16)) {
13325  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13326  }
13327  arg16 = static_cast< PLINT >(val16);
13328  ecode17 = SWIG_AsVal_int(args(14), &val17);
13329  if (!SWIG_IsOK(ecode17)) {
13330  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13331  }
13332  arg17 = static_cast< PLINT >(val17);
13333  ecode18 = SWIG_AsVal_int(args(15), &val18);
13334  if (!SWIG_IsOK(ecode18)) {
13335  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13336  }
13337  arg18 = static_cast< PLBOOL >(val18);
13338  {
13339  if ( _n_dims( args(16) ) > 1 )
13340  {
13341  error( "argument must be a scalar or vector" ); SWIG_fail;
13342  }
13343  if ( _dim( args(16), 0 ) != 6 )
13344  {
13345  error( "argument vectors must have length of 6" ); SWIG_fail;
13346  }
13347  temp19 = args(16).matrix_value();
13348  arg19 = &temp19( 0, 0 );
13349  }
13350  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);
13351  _outv = octave_value();
13352  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13353  {
13354 
13355  }
13356  {
13357 
13358  }
13359  {
13360 
13361  }
13362  return _out;
13363  fail:
13364  {
13365 
13366  }
13367  {
13368 
13369  }
13370  {
13371 
13372  }
13373  return octave_value_list();
13374  }
13375  catch(...) {
13376  {
13377 
13378  }
13379  {
13380 
13381  }
13382  {
13383 
13384  }
13385  throw;
13386  }
13387 }
13388 
13389 
13390 SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13391  PLFLT *arg1 = (PLFLT *) 0 ;
13392  PLINT arg2 ;
13393  PLINT arg3 ;
13394  char *arg4 = (char *) 0 ;
13395  PLFLT arg5 ;
13396  PLFLT arg6 ;
13397  PLFLT arg7 ;
13398  PLFLT arg8 ;
13399  PLFLT arg9 ;
13400  PLFLT arg10 ;
13401  PLINT arg11 ;
13402  PLFLT arg12 ;
13403  PLINT arg13 ;
13404  PLINT arg14 ;
13405  PLINT arg15 ;
13406  PLINT arg16 ;
13407  PLINT arg17 ;
13408  PLBOOL arg18 ;
13409  PLFLT *arg19 = (PLFLT *) 0 ;
13410  PLFLT *arg20 = (PLFLT *) 0 ;
13411  Matrix temp1 ;
13412  int res4 ;
13413  char *buf4 = 0 ;
13414  int alloc4 = 0 ;
13415  double val5 ;
13416  int ecode5 = 0 ;
13417  double val6 ;
13418  int ecode6 = 0 ;
13419  double val7 ;
13420  int ecode7 = 0 ;
13421  double val8 ;
13422  int ecode8 = 0 ;
13423  double val9 ;
13424  int ecode9 = 0 ;
13425  double val10 ;
13426  int ecode10 = 0 ;
13427  int val11 ;
13428  int ecode11 = 0 ;
13429  double val12 ;
13430  int ecode12 = 0 ;
13431  int val13 ;
13432  int ecode13 = 0 ;
13433  int val14 ;
13434  int ecode14 = 0 ;
13435  int val15 ;
13436  int ecode15 = 0 ;
13437  int val16 ;
13438  int ecode16 = 0 ;
13439  int val17 ;
13440  int ecode17 = 0 ;
13441  int val18 ;
13442  int ecode18 = 0 ;
13443  Matrix temp19 ;
13444  Matrix temp20 ;
13445  octave_value_list _out;
13446  octave_value_list *_outp=&_out;
13447  octave_value _outv;
13448 
13449  try {
13450  if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13451  SWIG_fail;
13452  }
13453  {
13454  if ( _n_dims( args(0) ) > 2 )
13455  {
13456  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13457  }
13458  temp1 = args(0).matrix_value();
13459  arg1 = &temp1( 0, 0 );
13460  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13461  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13462  }
13463  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13464  if (!SWIG_IsOK(res4)) {
13465  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13466  }
13467  arg4 = reinterpret_cast< char * >(buf4);
13468  ecode5 = SWIG_AsVal_double(args(2), &val5);
13469  if (!SWIG_IsOK(ecode5)) {
13470  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13471  }
13472  arg5 = static_cast< PLFLT >(val5);
13473  ecode6 = SWIG_AsVal_double(args(3), &val6);
13474  if (!SWIG_IsOK(ecode6)) {
13475  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13476  }
13477  arg6 = static_cast< PLFLT >(val6);
13478  ecode7 = SWIG_AsVal_double(args(4), &val7);
13479  if (!SWIG_IsOK(ecode7)) {
13480  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13481  }
13482  arg7 = static_cast< PLFLT >(val7);
13483  ecode8 = SWIG_AsVal_double(args(5), &val8);
13484  if (!SWIG_IsOK(ecode8)) {
13485  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13486  }
13487  arg8 = static_cast< PLFLT >(val8);
13488  ecode9 = SWIG_AsVal_double(args(6), &val9);
13489  if (!SWIG_IsOK(ecode9)) {
13490  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13491  }
13492  arg9 = static_cast< PLFLT >(val9);
13493  ecode10 = SWIG_AsVal_double(args(7), &val10);
13494  if (!SWIG_IsOK(ecode10)) {
13495  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13496  }
13497  arg10 = static_cast< PLFLT >(val10);
13498  ecode11 = SWIG_AsVal_int(args(8), &val11);
13499  if (!SWIG_IsOK(ecode11)) {
13500  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13501  }
13502  arg11 = static_cast< PLINT >(val11);
13503  ecode12 = SWIG_AsVal_double(args(9), &val12);
13504  if (!SWIG_IsOK(ecode12)) {
13505  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13506  }
13507  arg12 = static_cast< PLFLT >(val12);
13508  ecode13 = SWIG_AsVal_int(args(10), &val13);
13509  if (!SWIG_IsOK(ecode13)) {
13510  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13511  }
13512  arg13 = static_cast< PLINT >(val13);
13513  ecode14 = SWIG_AsVal_int(args(11), &val14);
13514  if (!SWIG_IsOK(ecode14)) {
13515  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13516  }
13517  arg14 = static_cast< PLINT >(val14);
13518  ecode15 = SWIG_AsVal_int(args(12), &val15);
13519  if (!SWIG_IsOK(ecode15)) {
13520  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13521  }
13522  arg15 = static_cast< PLINT >(val15);
13523  ecode16 = SWIG_AsVal_int(args(13), &val16);
13524  if (!SWIG_IsOK(ecode16)) {
13525  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13526  }
13527  arg16 = static_cast< PLINT >(val16);
13528  ecode17 = SWIG_AsVal_int(args(14), &val17);
13529  if (!SWIG_IsOK(ecode17)) {
13530  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13531  }
13532  arg17 = static_cast< PLINT >(val17);
13533  ecode18 = SWIG_AsVal_int(args(15), &val18);
13534  if (!SWIG_IsOK(ecode18)) {
13535  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13536  }
13537  arg18 = static_cast< PLBOOL >(val18);
13538  {
13539  if ( _n_dims( args(16) ) > 1 )
13540  {
13541  error( "argument must be a scalar or vector" ); SWIG_fail;
13542  }
13543  if ( _dim( args(16), 0 ) != Xlen )
13544  {
13545  error( "argument vectors must be same length" ); SWIG_fail;
13546  }
13547  temp19 = args(16).matrix_value();
13548  arg19 = &temp19( 0, 0 );
13549  }
13550  {
13551  if ( _n_dims( args(17) ) > 1 )
13552  {
13553  error( "argument must be a scalar or vector" ); SWIG_fail;
13554  }
13555  if ( _dim( args(17), 0 ) != Ylen )
13556  {
13557  error( "argument vectors must be same length" ); SWIG_fail;
13558  }
13559  temp20 = args(17).matrix_value();
13560  arg20 = &temp20( 0, 0 );
13561  }
13562  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);
13563  _outv = octave_value();
13564  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13565  {
13566 
13567  }
13568  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13569  {
13570 
13571  }
13572  {
13573 
13574  }
13575  return _out;
13576  fail:
13577  {
13578 
13579  }
13580  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13581  {
13582 
13583  }
13584  {
13585 
13586  }
13587  return octave_value_list();
13588  }
13589  catch(...) {
13590  {
13591 
13592  }
13593  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13594  {
13595 
13596  }
13597  {
13598 
13599  }
13600  throw;
13601  }
13602 }
13603 
13604 
13605 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13606  PLFLT *arg1 = (PLFLT *) 0 ;
13607  PLINT arg2 ;
13608  PLINT arg3 ;
13609  char *arg4 = (char *) 0 ;
13610  PLFLT arg5 ;
13611  PLFLT arg6 ;
13612  PLFLT arg7 ;
13613  PLFLT arg8 ;
13614  PLFLT arg9 ;
13615  PLFLT arg10 ;
13616  PLINT arg11 ;
13617  PLFLT arg12 ;
13618  PLINT arg13 ;
13619  PLINT arg14 ;
13620  PLINT arg15 ;
13621  PLINT arg16 ;
13622  PLINT arg17 ;
13623  PLBOOL arg18 ;
13624  PLFLT *arg19 = (PLFLT *) 0 ;
13625  PLFLT *arg20 = (PLFLT *) 0 ;
13626  Matrix temp1 ;
13627  int res4 ;
13628  char *buf4 = 0 ;
13629  int alloc4 = 0 ;
13630  double val5 ;
13631  int ecode5 = 0 ;
13632  double val6 ;
13633  int ecode6 = 0 ;
13634  double val7 ;
13635  int ecode7 = 0 ;
13636  double val8 ;
13637  int ecode8 = 0 ;
13638  double val9 ;
13639  int ecode9 = 0 ;
13640  double val10 ;
13641  int ecode10 = 0 ;
13642  int val11 ;
13643  int ecode11 = 0 ;
13644  double val12 ;
13645  int ecode12 = 0 ;
13646  int val13 ;
13647  int ecode13 = 0 ;
13648  int val14 ;
13649  int ecode14 = 0 ;
13650  int val15 ;
13651  int ecode15 = 0 ;
13652  int val16 ;
13653  int ecode16 = 0 ;
13654  int val17 ;
13655  int ecode17 = 0 ;
13656  int val18 ;
13657  int ecode18 = 0 ;
13658  Matrix temp19 ;
13659  Matrix temp20 ;
13660  octave_value_list _out;
13661  octave_value_list *_outp=&_out;
13662  octave_value _outv;
13663 
13664  try {
13665  if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13666  SWIG_fail;
13667  }
13668  {
13669  if ( _n_dims( args(0) ) > 2 )
13670  {
13671  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13672  }
13673  temp1 = args(0).matrix_value();
13674  arg1 = &temp1( 0, 0 );
13675  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13676  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13677  }
13678  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13679  if (!SWIG_IsOK(res4)) {
13680  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13681  }
13682  arg4 = reinterpret_cast< char * >(buf4);
13683  ecode5 = SWIG_AsVal_double(args(2), &val5);
13684  if (!SWIG_IsOK(ecode5)) {
13685  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13686  }
13687  arg5 = static_cast< PLFLT >(val5);
13688  ecode6 = SWIG_AsVal_double(args(3), &val6);
13689  if (!SWIG_IsOK(ecode6)) {
13690  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13691  }
13692  arg6 = static_cast< PLFLT >(val6);
13693  ecode7 = SWIG_AsVal_double(args(4), &val7);
13694  if (!SWIG_IsOK(ecode7)) {
13695  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13696  }
13697  arg7 = static_cast< PLFLT >(val7);
13698  ecode8 = SWIG_AsVal_double(args(5), &val8);
13699  if (!SWIG_IsOK(ecode8)) {
13700  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13701  }
13702  arg8 = static_cast< PLFLT >(val8);
13703  ecode9 = SWIG_AsVal_double(args(6), &val9);
13704  if (!SWIG_IsOK(ecode9)) {
13705  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13706  }
13707  arg9 = static_cast< PLFLT >(val9);
13708  ecode10 = SWIG_AsVal_double(args(7), &val10);
13709  if (!SWIG_IsOK(ecode10)) {
13710  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13711  }
13712  arg10 = static_cast< PLFLT >(val10);
13713  ecode11 = SWIG_AsVal_int(args(8), &val11);
13714  if (!SWIG_IsOK(ecode11)) {
13715  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13716  }
13717  arg11 = static_cast< PLINT >(val11);
13718  ecode12 = SWIG_AsVal_double(args(9), &val12);
13719  if (!SWIG_IsOK(ecode12)) {
13720  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13721  }
13722  arg12 = static_cast< PLFLT >(val12);
13723  ecode13 = SWIG_AsVal_int(args(10), &val13);
13724  if (!SWIG_IsOK(ecode13)) {
13725  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13726  }
13727  arg13 = static_cast< PLINT >(val13);
13728  ecode14 = SWIG_AsVal_int(args(11), &val14);
13729  if (!SWIG_IsOK(ecode14)) {
13730  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13731  }
13732  arg14 = static_cast< PLINT >(val14);
13733  ecode15 = SWIG_AsVal_int(args(12), &val15);
13734  if (!SWIG_IsOK(ecode15)) {
13735  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13736  }
13737  arg15 = static_cast< PLINT >(val15);
13738  ecode16 = SWIG_AsVal_int(args(13), &val16);
13739  if (!SWIG_IsOK(ecode16)) {
13740  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13741  }
13742  arg16 = static_cast< PLINT >(val16);
13743  ecode17 = SWIG_AsVal_int(args(14), &val17);
13744  if (!SWIG_IsOK(ecode17)) {
13745  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13746  }
13747  arg17 = static_cast< PLINT >(val17);
13748  ecode18 = SWIG_AsVal_int(args(15), &val18);
13749  if (!SWIG_IsOK(ecode18)) {
13750  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13751  }
13752  arg18 = static_cast< PLBOOL >(val18);
13753  {
13754  if ( _n_dims( args(16) ) > 2 )
13755  {
13756  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13757  }
13758  temp19 = args(16).matrix_value();
13759  arg19 = &temp19( 0, 0 );
13760  Xlen = (PLINT) ( _dim( args(16), 0 ) );
13761  Ylen = (PLINT) ( _dim( args(16), 1 ) );
13762  }
13763  {
13764  if ( _n_dims( args(17) ) > 2 )
13765  {
13766  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13767  }
13768  temp20 = args(17).matrix_value();
13769  arg20 = &temp20( 0, 0 );
13770  Xlen = (PLINT) ( _dim( args(17), 0 ) );
13771  Ylen = (PLINT) ( _dim( args(17), 1 ) );
13772  }
13773  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);
13774  _outv = octave_value();
13775  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13776  {
13777 
13778  }
13779  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13780  {
13781 
13782  }
13783  {
13784 
13785  }
13786  return _out;
13787  fail:
13788  {
13789 
13790  }
13791  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13792  {
13793 
13794  }
13795  {
13796 
13797  }
13798  return octave_value_list();
13799  }
13800  catch(...) {
13801  {
13802 
13803  }
13804  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13805  {
13806 
13807  }
13808  {
13809 
13810  }
13811  throw;
13812  }
13813 }
13814 
13815 
13817  PLFLT *arg1 = (PLFLT *) 0 ;
13818  PLINT arg2 ;
13819  PLINT arg3 ;
13820  PLFLT arg4 ;
13821  PLFLT arg5 ;
13822  PLFLT arg6 ;
13823  PLFLT arg7 ;
13824  PLFLT *arg8 = (PLFLT *) 0 ;
13825  PLINT arg9 ;
13826  PLINT arg10 ;
13827  PLINT arg11 ;
13828  PLINT arg12 ;
13829  PLBOOL arg13 ;
13830  Matrix temp1 ;
13831  double val4 ;
13832  int ecode4 = 0 ;
13833  double val5 ;
13834  int ecode5 = 0 ;
13835  double val6 ;
13836  int ecode6 = 0 ;
13837  double val7 ;
13838  int ecode7 = 0 ;
13839  Matrix temp8 ;
13840  int val10 ;
13841  int ecode10 = 0 ;
13842  int val11 ;
13843  int ecode11 = 0 ;
13844  int val12 ;
13845  int ecode12 = 0 ;
13846  int val13 ;
13847  int ecode13 = 0 ;
13848  octave_value_list _out;
13849  octave_value_list *_outp=&_out;
13850  octave_value _outv;
13851 
13852  try {
13853  if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
13854  SWIG_fail;
13855  }
13856  {
13857  if ( _n_dims( args(0) ) > 2 )
13858  {
13859  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13860  }
13861  temp1 = args(0).matrix_value();
13862  arg1 = &temp1( 0, 0 );
13863  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13864  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13865  }
13866  ecode4 = SWIG_AsVal_double(args(1), &val4);
13867  if (!SWIG_IsOK(ecode4)) {
13868  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
13869  }
13870  arg4 = static_cast< PLFLT >(val4);
13871  ecode5 = SWIG_AsVal_double(args(2), &val5);
13872  if (!SWIG_IsOK(ecode5)) {
13873  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
13874  }
13875  arg5 = static_cast< PLFLT >(val5);
13876  ecode6 = SWIG_AsVal_double(args(3), &val6);
13877  if (!SWIG_IsOK(ecode6)) {
13878  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
13879  }
13880  arg6 = static_cast< PLFLT >(val6);
13881  ecode7 = SWIG_AsVal_double(args(4), &val7);
13882  if (!SWIG_IsOK(ecode7)) {
13883  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
13884  }
13885  arg7 = static_cast< PLFLT >(val7);
13886  {
13887  if ( _n_dims( args(5) ) > 1 )
13888  {
13889  error( "argument must be a scalar or vector" ); SWIG_fail;
13890  }
13891  temp8 = args(5).matrix_value();
13892  arg8 = &temp8( 0, 0 );
13893  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13894  }
13895  ecode10 = SWIG_AsVal_int(args(6), &val10);
13896  if (!SWIG_IsOK(ecode10)) {
13897  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
13898  }
13899  arg10 = static_cast< PLINT >(val10);
13900  ecode11 = SWIG_AsVal_int(args(7), &val11);
13901  if (!SWIG_IsOK(ecode11)) {
13902  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
13903  }
13904  arg11 = static_cast< PLINT >(val11);
13905  ecode12 = SWIG_AsVal_int(args(8), &val12);
13906  if (!SWIG_IsOK(ecode12)) {
13907  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
13908  }
13909  arg12 = static_cast< PLINT >(val12);
13910  ecode13 = SWIG_AsVal_int(args(9), &val13);
13911  if (!SWIG_IsOK(ecode13)) {
13912  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
13913  }
13914  arg13 = static_cast< PLBOOL >(val13);
13915  my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
13916  _outv = octave_value();
13917  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13918  {
13919 
13920  }
13921  {
13922 
13923  }
13924  return _out;
13925  fail:
13926  {
13927 
13928  }
13929  {
13930 
13931  }
13932  return octave_value_list();
13933  }
13934  catch(...) {
13935  {
13936 
13937  }
13938  {
13939 
13940  }
13941  throw;
13942  }
13943 }
13944 
13945 
13946 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
13947  PLFLT *arg1 = (PLFLT *) 0 ;
13948  PLINT arg2 ;
13949  PLINT arg3 ;
13950  PLFLT arg4 ;
13951  PLFLT arg5 ;
13952  PLFLT arg6 ;
13953  PLFLT arg7 ;
13954  PLFLT *arg8 = (PLFLT *) 0 ;
13955  PLINT arg9 ;
13956  PLINT arg10 ;
13957  PLINT arg11 ;
13958  PLINT arg12 ;
13959  PLBOOL arg13 ;
13960  PLFLT *arg14 = (PLFLT *) 0 ;
13961  Matrix temp1 ;
13962  double val4 ;
13963  int ecode4 = 0 ;
13964  double val5 ;
13965  int ecode5 = 0 ;
13966  double val6 ;
13967  int ecode6 = 0 ;
13968  double val7 ;
13969  int ecode7 = 0 ;
13970  Matrix temp8 ;
13971  int val10 ;
13972  int ecode10 = 0 ;
13973  int val11 ;
13974  int ecode11 = 0 ;
13975  int val12 ;
13976  int ecode12 = 0 ;
13977  int val13 ;
13978  int ecode13 = 0 ;
13979  Matrix temp14 ;
13980  octave_value_list _out;
13981  octave_value_list *_outp=&_out;
13982  octave_value _outv;
13983 
13984  try {
13985  if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
13986  SWIG_fail;
13987  }
13988  {
13989  if ( _n_dims( args(0) ) > 2 )
13990  {
13991  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13992  }
13993  temp1 = args(0).matrix_value();
13994  arg1 = &temp1( 0, 0 );
13995  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13996  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13997  }
13998  ecode4 = SWIG_AsVal_double(args(1), &val4);
13999  if (!SWIG_IsOK(ecode4)) {
14000  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
14001  }
14002  arg4 = static_cast< PLFLT >(val4);
14003  ecode5 = SWIG_AsVal_double(args(2), &val5);
14004  if (!SWIG_IsOK(ecode5)) {
14005  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
14006  }
14007  arg5 = static_cast< PLFLT >(val5);
14008  ecode6 = SWIG_AsVal_double(args(3), &val6);
14009  if (!SWIG_IsOK(ecode6)) {
14010  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
14011  }
14012  arg6 = static_cast< PLFLT >(val6);
14013  ecode7 = SWIG_AsVal_double(args(4), &val7);
14014  if (!SWIG_IsOK(ecode7)) {
14015  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
14016  }
14017  arg7 = static_cast< PLFLT >(val7);
14018  {
14019  if ( _n_dims( args(5) ) > 1 )
14020  {
14021  error( "argument must be a scalar or vector" ); SWIG_fail;
14022  }
14023  temp8 = args(5).matrix_value();
14024  arg8 = &temp8( 0, 0 );
14025  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14026  }
14027  ecode10 = SWIG_AsVal_int(args(6), &val10);
14028  if (!SWIG_IsOK(ecode10)) {
14029  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
14030  }
14031  arg10 = static_cast< PLINT >(val10);
14032  ecode11 = SWIG_AsVal_int(args(7), &val11);
14033  if (!SWIG_IsOK(ecode11)) {
14034  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
14035  }
14036  arg11 = static_cast< PLINT >(val11);
14037  ecode12 = SWIG_AsVal_int(args(8), &val12);
14038  if (!SWIG_IsOK(ecode12)) {
14039  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
14040  }
14041  arg12 = static_cast< PLINT >(val12);
14042  ecode13 = SWIG_AsVal_int(args(9), &val13);
14043  if (!SWIG_IsOK(ecode13)) {
14044  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
14045  }
14046  arg13 = static_cast< PLBOOL >(val13);
14047  {
14048  if ( _n_dims( args(10) ) > 1 )
14049  {
14050  error( "argument must be a scalar or vector" ); SWIG_fail;
14051  }
14052  if ( _dim( args(10), 0 ) != 6 )
14053  {
14054  error( "argument vectors must have length of 6" ); SWIG_fail;
14055  }
14056  temp14 = args(10).matrix_value();
14057  arg14 = &temp14( 0, 0 );
14058  }
14059  my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14060  _outv = octave_value();
14061  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14062  {
14063 
14064  }
14065  {
14066 
14067  }
14068  {
14069 
14070  }
14071  return _out;
14072  fail:
14073  {
14074 
14075  }
14076  {
14077 
14078  }
14079  {
14080 
14081  }
14082  return octave_value_list();
14083  }
14084  catch(...) {
14085  {
14086 
14087  }
14088  {
14089 
14090  }
14091  {
14092 
14093  }
14094  throw;
14095  }
14096 }
14097 
14098 
14099 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
14100  PLFLT *arg1 = (PLFLT *) 0 ;
14101  PLINT arg2 ;
14102  PLINT arg3 ;
14103  PLFLT arg4 ;
14104  PLFLT arg5 ;
14105  PLFLT arg6 ;
14106  PLFLT arg7 ;
14107  PLFLT *arg8 = (PLFLT *) 0 ;
14108  PLINT arg9 ;
14109  PLINT arg10 ;
14110  PLINT arg11 ;
14111  PLINT arg12 ;
14112  PLBOOL arg13 ;
14113  PLFLT *arg14 = (PLFLT *) 0 ;
14114  PLFLT *arg15 = (PLFLT *) 0 ;
14115  Matrix temp1 ;
14116  double val4 ;
14117  int ecode4 = 0 ;
14118  double val5 ;
14119  int ecode5 = 0 ;
14120  double val6 ;
14121  int ecode6 = 0 ;
14122  double val7 ;
14123  int ecode7 = 0 ;
14124  Matrix temp8 ;
14125  int val10 ;
14126  int ecode10 = 0 ;
14127  int val11 ;
14128  int ecode11 = 0 ;
14129  int val12 ;
14130  int ecode12 = 0 ;
14131  int val13 ;
14132  int ecode13 = 0 ;
14133  Matrix temp14 ;
14134  Matrix temp15 ;
14135  octave_value_list _out;
14136  octave_value_list *_outp=&_out;
14137  octave_value _outv;
14138 
14139  try {
14140  if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
14141  SWIG_fail;
14142  }
14143  {
14144  if ( _n_dims( args(0) ) > 2 )
14145  {
14146  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14147  }
14148  temp1 = args(0).matrix_value();
14149  arg1 = &temp1( 0, 0 );
14150  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14151  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14152  }
14153  ecode4 = SWIG_AsVal_double(args(1), &val4);
14154  if (!SWIG_IsOK(ecode4)) {
14155  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
14156  }
14157  arg4 = static_cast< PLFLT >(val4);
14158  ecode5 = SWIG_AsVal_double(args(2), &val5);
14159  if (!SWIG_IsOK(ecode5)) {
14160  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
14161  }
14162  arg5 = static_cast< PLFLT >(val5);
14163  ecode6 = SWIG_AsVal_double(args(3), &val6);
14164  if (!SWIG_IsOK(ecode6)) {
14165  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
14166  }
14167  arg6 = static_cast< PLFLT >(val6);
14168  ecode7 = SWIG_AsVal_double(args(4), &val7);
14169  if (!SWIG_IsOK(ecode7)) {
14170  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
14171  }
14172  arg7 = static_cast< PLFLT >(val7);
14173  {
14174  if ( _n_dims( args(5) ) > 1 )
14175  {
14176  error( "argument must be a scalar or vector" ); SWIG_fail;
14177  }
14178  temp8 = args(5).matrix_value();
14179  arg8 = &temp8( 0, 0 );
14180  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14181  }
14182  ecode10 = SWIG_AsVal_int(args(6), &val10);
14183  if (!SWIG_IsOK(ecode10)) {
14184  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
14185  }
14186  arg10 = static_cast< PLINT >(val10);
14187  ecode11 = SWIG_AsVal_int(args(7), &val11);
14188  if (!SWIG_IsOK(ecode11)) {
14189  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
14190  }
14191  arg11 = static_cast< PLINT >(val11);
14192  ecode12 = SWIG_AsVal_int(args(8), &val12);
14193  if (!SWIG_IsOK(ecode12)) {
14194  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
14195  }
14196  arg12 = static_cast< PLINT >(val12);
14197  ecode13 = SWIG_AsVal_int(args(9), &val13);
14198  if (!SWIG_IsOK(ecode13)) {
14199  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
14200  }
14201  arg13 = static_cast< PLBOOL >(val13);
14202  {
14203  if ( _n_dims( args(10) ) > 1 )
14204  {
14205  error( "argument must be a scalar or vector" ); SWIG_fail;
14206  }
14207  if ( _dim( args(10), 0 ) != Xlen )
14208  {
14209  error( "argument vectors must be same length" ); SWIG_fail;
14210  }
14211  temp14 = args(10).matrix_value();
14212  arg14 = &temp14( 0, 0 );
14213  }
14214  {
14215  if ( _n_dims( args(11) ) > 1 )
14216  {
14217  error( "argument must be a scalar or vector" ); SWIG_fail;
14218  }
14219  if ( _dim( args(11), 0 ) != Ylen )
14220  {
14221  error( "argument vectors must be same length" ); SWIG_fail;
14222  }
14223  temp15 = args(11).matrix_value();
14224  arg15 = &temp15( 0, 0 );
14225  }
14226  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);
14227  _outv = octave_value();
14228  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14229  {
14230 
14231  }
14232  {
14233 
14234  }
14235  {
14236 
14237  }
14238  {
14239 
14240  }
14241  return _out;
14242  fail:
14243  {
14244 
14245  }
14246  {
14247 
14248  }
14249  {
14250 
14251  }
14252  {
14253 
14254  }
14255  return octave_value_list();
14256  }
14257  catch(...) {
14258  {
14259 
14260  }
14261  {
14262 
14263  }
14264  {
14265 
14266  }
14267  {
14268 
14269  }
14270  throw;
14271  }
14272 }
14273 
14274 
14275 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
14276  PLFLT *arg1 = (PLFLT *) 0 ;
14277  PLINT arg2 ;
14278  PLINT arg3 ;
14279  PLFLT arg4 ;
14280  PLFLT arg5 ;
14281  PLFLT arg6 ;
14282  PLFLT arg7 ;
14283  PLFLT *arg8 = (PLFLT *) 0 ;
14284  PLINT arg9 ;
14285  PLINT arg10 ;
14286  PLINT arg11 ;
14287  PLINT arg12 ;
14288  PLBOOL arg13 ;
14289  PLFLT *arg14 = (PLFLT *) 0 ;
14290  PLFLT *arg15 = (PLFLT *) 0 ;
14291  Matrix temp1 ;
14292  double val4 ;
14293  int ecode4 = 0 ;
14294  double val5 ;
14295  int ecode5 = 0 ;
14296  double val6 ;
14297  int ecode6 = 0 ;
14298  double val7 ;
14299  int ecode7 = 0 ;
14300  Matrix temp8 ;
14301  int val10 ;
14302  int ecode10 = 0 ;
14303  int val11 ;
14304  int ecode11 = 0 ;
14305  int val12 ;
14306  int ecode12 = 0 ;
14307  int val13 ;
14308  int ecode13 = 0 ;
14309  Matrix temp14 ;
14310  Matrix temp15 ;
14311  octave_value_list _out;
14312  octave_value_list *_outp=&_out;
14313  octave_value _outv;
14314 
14315  try {
14316  if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
14317  SWIG_fail;
14318  }
14319  {
14320  if ( _n_dims( args(0) ) > 2 )
14321  {
14322  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14323  }
14324  temp1 = args(0).matrix_value();
14325  arg1 = &temp1( 0, 0 );
14326  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14327  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14328  }
14329  ecode4 = SWIG_AsVal_double(args(1), &val4);
14330  if (!SWIG_IsOK(ecode4)) {
14331  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
14332  }
14333  arg4 = static_cast< PLFLT >(val4);
14334  ecode5 = SWIG_AsVal_double(args(2), &val5);
14335  if (!SWIG_IsOK(ecode5)) {
14336  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
14337  }
14338  arg5 = static_cast< PLFLT >(val5);
14339  ecode6 = SWIG_AsVal_double(args(3), &val6);
14340  if (!SWIG_IsOK(ecode6)) {
14341  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
14342  }
14343  arg6 = static_cast< PLFLT >(val6);
14344  ecode7 = SWIG_AsVal_double(args(4), &val7);
14345  if (!SWIG_IsOK(ecode7)) {
14346  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
14347  }
14348  arg7 = static_cast< PLFLT >(val7);
14349  {
14350  if ( _n_dims( args(5) ) > 1 )
14351  {
14352  error( "argument must be a scalar or vector" ); SWIG_fail;
14353  }
14354  temp8 = args(5).matrix_value();
14355  arg8 = &temp8( 0, 0 );
14356  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14357  }
14358  ecode10 = SWIG_AsVal_int(args(6), &val10);
14359  if (!SWIG_IsOK(ecode10)) {
14360  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
14361  }
14362  arg10 = static_cast< PLINT >(val10);
14363  ecode11 = SWIG_AsVal_int(args(7), &val11);
14364  if (!SWIG_IsOK(ecode11)) {
14365  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
14366  }
14367  arg11 = static_cast< PLINT >(val11);
14368  ecode12 = SWIG_AsVal_int(args(8), &val12);
14369  if (!SWIG_IsOK(ecode12)) {
14370  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
14371  }
14372  arg12 = static_cast< PLINT >(val12);
14373  ecode13 = SWIG_AsVal_int(args(9), &val13);
14374  if (!SWIG_IsOK(ecode13)) {
14375  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
14376  }
14377  arg13 = static_cast< PLBOOL >(val13);
14378  {
14379  if ( _n_dims( args(10) ) > 2 )
14380  {
14381  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14382  }
14383  temp14 = args(10).matrix_value();
14384  arg14 = &temp14( 0, 0 );
14385  Xlen = (PLINT) ( _dim( args(10), 0 ) );
14386  Ylen = (PLINT) ( _dim( args(10), 1 ) );
14387  }
14388  {
14389  if ( _n_dims( args(11) ) > 2 )
14390  {
14391  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14392  }
14393  temp15 = args(11).matrix_value();
14394  arg15 = &temp15( 0, 0 );
14395  Xlen = (PLINT) ( _dim( args(11), 0 ) );
14396  Ylen = (PLINT) ( _dim( args(11), 1 ) );
14397  }
14398  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);
14399  _outv = octave_value();
14400  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14401  {
14402 
14403  }
14404  {
14405 
14406  }
14407  {
14408 
14409  }
14410  {
14411 
14412  }
14413  return _out;
14414  fail:
14415  {
14416 
14417  }
14418  {
14419 
14420  }
14421  {
14422 
14423  }
14424  {
14425 
14426  }
14427  return octave_value_list();
14428  }
14429  catch(...) {
14430  {
14431 
14432  }
14433  {
14434 
14435  }
14436  {
14437 
14438  }
14439  {
14440 
14441  }
14442  throw;
14443  }
14444 }
14445 
14446 
14448  PLFLT *arg1 = (PLFLT *) 0 ;
14449  PLFLT *arg2 = (PLFLT *) 0 ;
14450  PLINT arg3 ;
14451  PLINT arg4 ;
14452  PLFLT arg5 ;
14453  PLFLT *arg6 = (PLFLT *) 0 ;
14454  Matrix temp1 ;
14455  Matrix temp2 ;
14456  double val5 ;
14457  int ecode5 = 0 ;
14458  Matrix temp6 ;
14459  octave_value_list _out;
14460  octave_value_list *_outp=&_out;
14461  octave_value _outv;
14462 
14463  try {
14464  if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14465  SWIG_fail;
14466  }
14467  {
14468  if ( _n_dims( args(0) ) > 2 )
14469  {
14470  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14471  }
14472  temp1 = args(0).matrix_value();
14473  arg1 = &temp1( 0, 0 );
14474  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14475  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14476  }
14477  {
14478  if ( _n_dims( args(1) ) > 2 )
14479  {
14480  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14481  }
14482  if ( _dim( args(1), 0 ) != Xlen )
14483  {
14484  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14485  }
14486  if ( _dim( args(1), 1 ) != Ylen )
14487  {
14488  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14489  }
14490  temp2 = args(1).matrix_value();
14491  arg2 = &temp2( 0, 0 );
14492  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14493  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14494  }
14495  ecode5 = SWIG_AsVal_double(args(2), &val5);
14496  if (!SWIG_IsOK(ecode5)) {
14497  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14498  }
14499  arg5 = static_cast< PLFLT >(val5);
14500  {
14501  if ( _n_dims( args(3) ) > 1 )
14502  {
14503  error( "argument must be a scalar or vector" ); SWIG_fail;
14504  }
14505  if ( _dim( args(3), 0 ) != 6 )
14506  {
14507  error( "argument vectors must have length of 6" ); SWIG_fail;
14508  }
14509  temp6 = args(3).matrix_value();
14510  arg6 = &temp6( 0, 0 );
14511  }
14512  my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14513  _outv = octave_value();
14514  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14515  {
14516 
14517  }
14518  {
14519 
14520  }
14521  {
14522 
14523  }
14524  return _out;
14525  fail:
14526  {
14527 
14528  }
14529  {
14530 
14531  }
14532  {
14533 
14534  }
14535  return octave_value_list();
14536  }
14537  catch(...) {
14538  {
14539 
14540  }
14541  {
14542 
14543  }
14544  {
14545 
14546  }
14547  throw;
14548  }
14549 }
14550 
14551 
14552 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14553  PLFLT *arg1 = (PLFLT *) 0 ;
14554  PLFLT *arg2 = (PLFLT *) 0 ;
14555  PLINT arg3 ;
14556  PLINT arg4 ;
14557  PLFLT arg5 ;
14558  PLFLT *arg6 = (PLFLT *) 0 ;
14559  PLFLT *arg7 = (PLFLT *) 0 ;
14560  Matrix temp1 ;
14561  Matrix temp2 ;
14562  double val5 ;
14563  int ecode5 = 0 ;
14564  Matrix temp6 ;
14565  Matrix temp7 ;
14566  octave_value_list _out;
14567  octave_value_list *_outp=&_out;
14568  octave_value _outv;
14569 
14570  try {
14571  if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14572  SWIG_fail;
14573  }
14574  {
14575  if ( _n_dims( args(0) ) > 2 )
14576  {
14577  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14578  }
14579  temp1 = args(0).matrix_value();
14580  arg1 = &temp1( 0, 0 );
14581  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14582  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14583  }
14584  {
14585  if ( _n_dims( args(1) ) > 2 )
14586  {
14587  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14588  }
14589  if ( _dim( args(1), 0 ) != Xlen )
14590  {
14591  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14592  }
14593  if ( _dim( args(1), 1 ) != Ylen )
14594  {
14595  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14596  }
14597  temp2 = args(1).matrix_value();
14598  arg2 = &temp2( 0, 0 );
14599  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14600  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14601  }
14602  ecode5 = SWIG_AsVal_double(args(2), &val5);
14603  if (!SWIG_IsOK(ecode5)) {
14604  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14605  }
14606  arg5 = static_cast< PLFLT >(val5);
14607  {
14608  if ( _n_dims( args(3) ) > 1 )
14609  {
14610  error( "argument must be a scalar or vector" ); SWIG_fail;
14611  }
14612  if ( _dim( args(3), 0 ) != Xlen )
14613  {
14614  error( "argument vectors must be same length" ); SWIG_fail;
14615  }
14616  temp6 = args(3).matrix_value();
14617  arg6 = &temp6( 0, 0 );
14618  }
14619  {
14620  if ( _n_dims( args(4) ) > 1 )
14621  {
14622  error( "argument must be a scalar or vector" ); SWIG_fail;
14623  }
14624  if ( _dim( args(4), 0 ) != Ylen )
14625  {
14626  error( "argument vectors must be same length" ); SWIG_fail;
14627  }
14628  temp7 = args(4).matrix_value();
14629  arg7 = &temp7( 0, 0 );
14630  }
14631  my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14632  _outv = octave_value();
14633  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14634  {
14635 
14636  }
14637  {
14638 
14639  }
14640  {
14641 
14642  }
14643  {
14644 
14645  }
14646  return _out;
14647  fail:
14648  {
14649 
14650  }
14651  {
14652 
14653  }
14654  {
14655 
14656  }
14657  {
14658 
14659  }
14660  return octave_value_list();
14661  }
14662  catch(...) {
14663  {
14664 
14665  }
14666  {
14667 
14668  }
14669  {
14670 
14671  }
14672  {
14673 
14674  }
14675  throw;
14676  }
14677 }
14678 
14679 
14680 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14681  PLFLT *arg1 = (PLFLT *) 0 ;
14682  PLFLT *arg2 = (PLFLT *) 0 ;
14683  PLINT arg3 ;
14684  PLINT arg4 ;
14685  PLFLT arg5 ;
14686  PLFLT *arg6 = (PLFLT *) 0 ;
14687  PLFLT *arg7 = (PLFLT *) 0 ;
14688  Matrix temp1 ;
14689  Matrix temp2 ;
14690  double val5 ;
14691  int ecode5 = 0 ;
14692  Matrix temp6 ;
14693  Matrix temp7 ;
14694  octave_value_list _out;
14695  octave_value_list *_outp=&_out;
14696  octave_value _outv;
14697 
14698  try {
14699  if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14700  SWIG_fail;
14701  }
14702  {
14703  if ( _n_dims( args(0) ) > 2 )
14704  {
14705  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14706  }
14707  temp1 = args(0).matrix_value();
14708  arg1 = &temp1( 0, 0 );
14709  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14710  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14711  }
14712  {
14713  if ( _n_dims( args(1) ) > 2 )
14714  {
14715  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14716  }
14717  if ( _dim( args(1), 0 ) != Xlen )
14718  {
14719  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14720  }
14721  if ( _dim( args(1), 1 ) != Ylen )
14722  {
14723  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14724  }
14725  temp2 = args(1).matrix_value();
14726  arg2 = &temp2( 0, 0 );
14727  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14728  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14729  }
14730  ecode5 = SWIG_AsVal_double(args(2), &val5);
14731  if (!SWIG_IsOK(ecode5)) {
14732  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14733  }
14734  arg5 = static_cast< PLFLT >(val5);
14735  {
14736  if ( _n_dims( args(3) ) > 2 )
14737  {
14738  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14739  }
14740  temp6 = args(3).matrix_value();
14741  arg6 = &temp6( 0, 0 );
14742  Xlen = (PLINT) ( _dim( args(3), 0 ) );
14743  Ylen = (PLINT) ( _dim( args(3), 1 ) );
14744  }
14745  {
14746  if ( _n_dims( args(4) ) > 2 )
14747  {
14748  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14749  }
14750  temp7 = args(4).matrix_value();
14751  arg7 = &temp7( 0, 0 );
14752  Xlen = (PLINT) ( _dim( args(4), 0 ) );
14753  Ylen = (PLINT) ( _dim( args(4), 1 ) );
14754  }
14755  my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14756  _outv = octave_value();
14757  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14758  {
14759 
14760  }
14761  {
14762 
14763  }
14764  {
14765 
14766  }
14767  {
14768 
14769  }
14770  return _out;
14771  fail:
14772  {
14773 
14774  }
14775  {
14776 
14777  }
14778  {
14779 
14780  }
14781  {
14782 
14783  }
14784  return octave_value_list();
14785  }
14786  catch(...) {
14787  {
14788 
14789  }
14790  {
14791 
14792  }
14793  {
14794 
14795  }
14796  {
14797 
14798  }
14799  throw;
14800  }
14801 }
14802 
14803 
14804 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
14805  PLFLT *arg1 = (PLFLT *) 0 ;
14806  PLINT arg2 ;
14807  PLINT arg3 ;
14808  PLFLT arg4 ;
14809  PLFLT arg5 ;
14810  PLFLT arg6 ;
14811  PLFLT arg7 ;
14812  PLFLT arg8 ;
14813  PLFLT arg9 ;
14814  PLFLT arg10 ;
14815  PLFLT arg11 ;
14816  PLFLT arg12 ;
14817  PLFLT arg13 ;
14818  Matrix temp1 ;
14819  double val4 ;
14820  int ecode4 = 0 ;
14821  double val5 ;
14822  int ecode5 = 0 ;
14823  double val6 ;
14824  int ecode6 = 0 ;
14825  double val7 ;
14826  int ecode7 = 0 ;
14827  double val8 ;
14828  int ecode8 = 0 ;
14829  double val9 ;
14830  int ecode9 = 0 ;
14831  double val10 ;
14832  int ecode10 = 0 ;
14833  double val11 ;
14834  int ecode11 = 0 ;
14835  double val12 ;
14836  int ecode12 = 0 ;
14837  double val13 ;
14838  int ecode13 = 0 ;
14839  octave_value_list _out;
14840  octave_value_list *_outp=&_out;
14841  octave_value _outv;
14842 
14843  try {
14844  if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
14845  SWIG_fail;
14846  }
14847  {
14848  if ( _n_dims( args(0) ) > 2 )
14849  {
14850  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14851  }
14852  temp1 = args(0).matrix_value();
14853  arg1 = &temp1( 0, 0 );
14854  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14855  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14856  }
14857  ecode4 = SWIG_AsVal_double(args(1), &val4);
14858  if (!SWIG_IsOK(ecode4)) {
14859  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
14860  }
14861  arg4 = static_cast< PLFLT >(val4);
14862  ecode5 = SWIG_AsVal_double(args(2), &val5);
14863  if (!SWIG_IsOK(ecode5)) {
14864  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
14865  }
14866  arg5 = static_cast< PLFLT >(val5);
14867  ecode6 = SWIG_AsVal_double(args(3), &val6);
14868  if (!SWIG_IsOK(ecode6)) {
14869  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
14870  }
14871  arg6 = static_cast< PLFLT >(val6);
14872  ecode7 = SWIG_AsVal_double(args(4), &val7);
14873  if (!SWIG_IsOK(ecode7)) {
14874  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
14875  }
14876  arg7 = static_cast< PLFLT >(val7);
14877  ecode8 = SWIG_AsVal_double(args(5), &val8);
14878  if (!SWIG_IsOK(ecode8)) {
14879  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
14880  }
14881  arg8 = static_cast< PLFLT >(val8);
14882  ecode9 = SWIG_AsVal_double(args(6), &val9);
14883  if (!SWIG_IsOK(ecode9)) {
14884  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
14885  }
14886  arg9 = static_cast< PLFLT >(val9);
14887  ecode10 = SWIG_AsVal_double(args(7), &val10);
14888  if (!SWIG_IsOK(ecode10)) {
14889  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
14890  }
14891  arg10 = static_cast< PLFLT >(val10);
14892  ecode11 = SWIG_AsVal_double(args(8), &val11);
14893  if (!SWIG_IsOK(ecode11)) {
14894  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
14895  }
14896  arg11 = static_cast< PLFLT >(val11);
14897  ecode12 = SWIG_AsVal_double(args(9), &val12);
14898  if (!SWIG_IsOK(ecode12)) {
14899  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
14900  }
14901  arg12 = static_cast< PLFLT >(val12);
14902  ecode13 = SWIG_AsVal_double(args(10), &val13);
14903  if (!SWIG_IsOK(ecode13)) {
14904  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
14905  }
14906  arg13 = static_cast< PLFLT >(val13);
14907  my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14908  _outv = octave_value();
14909  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14910  {
14911 
14912  }
14913  return _out;
14914  fail:
14915  {
14916 
14917  }
14918  return octave_value_list();
14919  }
14920  catch(...) {
14921  {
14922 
14923  }
14924  throw;
14925  }
14926 }
14927 
14928 
14930  PLFLT *arg1 = (PLFLT *) 0 ;
14931  PLINT arg2 ;
14932  PLINT arg3 ;
14933  PLFLT arg4 ;
14934  PLFLT arg5 ;
14935  PLFLT arg6 ;
14936  PLFLT arg7 ;
14937  PLFLT arg8 ;
14938  PLFLT arg9 ;
14939  PLFLT arg10 ;
14940  PLFLT arg11 ;
14941  Matrix temp1 ;
14942  double val4 ;
14943  int ecode4 = 0 ;
14944  double val5 ;
14945  int ecode5 = 0 ;
14946  double val6 ;
14947  int ecode6 = 0 ;
14948  double val7 ;
14949  int ecode7 = 0 ;
14950  double val8 ;
14951  int ecode8 = 0 ;
14952  double val9 ;
14953  int ecode9 = 0 ;
14954  double val10 ;
14955  int ecode10 = 0 ;
14956  double val11 ;
14957  int ecode11 = 0 ;
14958  octave_value_list _out;
14959  octave_value_list *_outp=&_out;
14960  octave_value _outv;
14961 
14962  try {
14963  if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
14964  SWIG_fail;
14965  }
14966  {
14967  if ( _n_dims( args(0) ) > 2 )
14968  {
14969  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14970  }
14971  temp1 = args(0).matrix_value();
14972  arg1 = &temp1( 0, 0 );
14973  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14974  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14975  }
14976  ecode4 = SWIG_AsVal_double(args(1), &val4);
14977  if (!SWIG_IsOK(ecode4)) {
14978  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14979  }
14980  arg4 = static_cast< PLFLT >(val4);
14981  ecode5 = SWIG_AsVal_double(args(2), &val5);
14982  if (!SWIG_IsOK(ecode5)) {
14983  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14984  }
14985  arg5 = static_cast< PLFLT >(val5);
14986  ecode6 = SWIG_AsVal_double(args(3), &val6);
14987  if (!SWIG_IsOK(ecode6)) {
14988  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14989  }
14990  arg6 = static_cast< PLFLT >(val6);
14991  ecode7 = SWIG_AsVal_double(args(4), &val7);
14992  if (!SWIG_IsOK(ecode7)) {
14993  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14994  }
14995  arg7 = static_cast< PLFLT >(val7);
14996  ecode8 = SWIG_AsVal_double(args(5), &val8);
14997  if (!SWIG_IsOK(ecode8)) {
14998  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14999  }
15000  arg8 = static_cast< PLFLT >(val8);
15001  ecode9 = SWIG_AsVal_double(args(6), &val9);
15002  if (!SWIG_IsOK(ecode9)) {
15003  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15004  }
15005  arg9 = static_cast< PLFLT >(val9);
15006  ecode10 = SWIG_AsVal_double(args(7), &val10);
15007  if (!SWIG_IsOK(ecode10)) {
15008  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15009  }
15010  arg10 = static_cast< PLFLT >(val10);
15011  ecode11 = SWIG_AsVal_double(args(8), &val11);
15012  if (!SWIG_IsOK(ecode11)) {
15013  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15014  }
15015  arg11 = static_cast< PLFLT >(val11);
15016  my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15017  _outv = octave_value();
15018  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15019  {
15020 
15021  }
15022  return _out;
15023  fail:
15024  {
15025 
15026  }
15027  return octave_value_list();
15028  }
15029  catch(...) {
15030  {
15031 
15032  }
15033  throw;
15034  }
15035 }
15036 
15037 
15038 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
15039  PLFLT *arg1 = (PLFLT *) 0 ;
15040  PLINT arg2 ;
15041  PLINT arg3 ;
15042  PLFLT arg4 ;
15043  PLFLT arg5 ;
15044  PLFLT arg6 ;
15045  PLFLT arg7 ;
15046  PLFLT arg8 ;
15047  PLFLT arg9 ;
15048  PLFLT arg10 ;
15049  PLFLT arg11 ;
15050  PLFLT *arg12 = (PLFLT *) 0 ;
15051  Matrix temp1 ;
15052  double val4 ;
15053  int ecode4 = 0 ;
15054  double val5 ;
15055  int ecode5 = 0 ;
15056  double val6 ;
15057  int ecode6 = 0 ;
15058  double val7 ;
15059  int ecode7 = 0 ;
15060  double val8 ;
15061  int ecode8 = 0 ;
15062  double val9 ;
15063  int ecode9 = 0 ;
15064  double val10 ;
15065  int ecode10 = 0 ;
15066  double val11 ;
15067  int ecode11 = 0 ;
15068  Matrix temp12 ;
15069  octave_value_list _out;
15070  octave_value_list *_outp=&_out;
15071  octave_value _outv;
15072 
15073  try {
15074  if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
15075  SWIG_fail;
15076  }
15077  {
15078  if ( _n_dims( args(0) ) > 2 )
15079  {
15080  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15081  }
15082  temp1 = args(0).matrix_value();
15083  arg1 = &temp1( 0, 0 );
15084  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15085  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15086  }
15087  ecode4 = SWIG_AsVal_double(args(1), &val4);
15088  if (!SWIG_IsOK(ecode4)) {
15089  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
15090  }
15091  arg4 = static_cast< PLFLT >(val4);
15092  ecode5 = SWIG_AsVal_double(args(2), &val5);
15093  if (!SWIG_IsOK(ecode5)) {
15094  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
15095  }
15096  arg5 = static_cast< PLFLT >(val5);
15097  ecode6 = SWIG_AsVal_double(args(3), &val6);
15098  if (!SWIG_IsOK(ecode6)) {
15099  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
15100  }
15101  arg6 = static_cast< PLFLT >(val6);
15102  ecode7 = SWIG_AsVal_double(args(4), &val7);
15103  if (!SWIG_IsOK(ecode7)) {
15104  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
15105  }
15106  arg7 = static_cast< PLFLT >(val7);
15107  ecode8 = SWIG_AsVal_double(args(5), &val8);
15108  if (!SWIG_IsOK(ecode8)) {
15109  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
15110  }
15111  arg8 = static_cast< PLFLT >(val8);
15112  ecode9 = SWIG_AsVal_double(args(6), &val9);
15113  if (!SWIG_IsOK(ecode9)) {
15114  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
15115  }
15116  arg9 = static_cast< PLFLT >(val9);
15117  ecode10 = SWIG_AsVal_double(args(7), &val10);
15118  if (!SWIG_IsOK(ecode10)) {
15119  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
15120  }
15121  arg10 = static_cast< PLFLT >(val10);
15122  ecode11 = SWIG_AsVal_double(args(8), &val11);
15123  if (!SWIG_IsOK(ecode11)) {
15124  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
15125  }
15126  arg11 = static_cast< PLFLT >(val11);
15127  {
15128  if ( _n_dims( args(9) ) > 1 )
15129  {
15130  error( "argument must be a scalar or vector" ); SWIG_fail;
15131  }
15132  if ( _dim( args(9), 0 ) != 6 )
15133  {
15134  error( "argument vectors must have length of 6" ); SWIG_fail;
15135  }
15136  temp12 = args(9).matrix_value();
15137  arg12 = &temp12( 0, 0 );
15138  }
15139  my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15140  _outv = octave_value();
15141  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15142  {
15143 
15144  }
15145  {
15146 
15147  }
15148  return _out;
15149  fail:
15150  {
15151 
15152  }
15153  {
15154 
15155  }
15156  return octave_value_list();
15157  }
15158  catch(...) {
15159  {
15160 
15161  }
15162  {
15163 
15164  }
15165  throw;
15166  }
15167 }
15168 
15169 
15170 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
15171  PLFLT *arg1 = (PLFLT *) 0 ;
15172  PLINT arg2 ;
15173  PLINT arg3 ;
15174  PLFLT arg4 ;
15175  PLFLT arg5 ;
15176  PLFLT arg6 ;
15177  PLFLT arg7 ;
15178  PLFLT arg8 ;
15179  PLFLT arg9 ;
15180  PLFLT arg10 ;
15181  PLFLT arg11 ;
15182  PLFLT *arg12 = (PLFLT *) 0 ;
15183  PLFLT *arg13 = (PLFLT *) 0 ;
15184  Matrix temp1 ;
15185  double val4 ;
15186  int ecode4 = 0 ;
15187  double val5 ;
15188  int ecode5 = 0 ;
15189  double val6 ;
15190  int ecode6 = 0 ;
15191  double val7 ;
15192  int ecode7 = 0 ;
15193  double val8 ;
15194  int ecode8 = 0 ;
15195  double val9 ;
15196  int ecode9 = 0 ;
15197  double val10 ;
15198  int ecode10 = 0 ;
15199  double val11 ;
15200  int ecode11 = 0 ;
15201  Matrix temp12 ;
15202  Matrix temp13 ;
15203  octave_value_list _out;
15204  octave_value_list *_outp=&_out;
15205  octave_value _outv;
15206 
15207  try {
15208  if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
15209  SWIG_fail;
15210  }
15211  {
15212  if ( _n_dims( args(0) ) > 2 )
15213  {
15214  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15215  }
15216  temp1 = args(0).matrix_value();
15217  arg1 = &temp1( 0, 0 );
15218  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15219  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15220  }
15221  ecode4 = SWIG_AsVal_double(args(1), &val4);
15222  if (!SWIG_IsOK(ecode4)) {
15223  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
15224  }
15225  arg4 = static_cast< PLFLT >(val4);
15226  ecode5 = SWIG_AsVal_double(args(2), &val5);
15227  if (!SWIG_IsOK(ecode5)) {
15228  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
15229  }
15230  arg5 = static_cast< PLFLT >(val5);
15231  ecode6 = SWIG_AsVal_double(args(3), &val6);
15232  if (!SWIG_IsOK(ecode6)) {
15233  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
15234  }
15235  arg6 = static_cast< PLFLT >(val6);
15236  ecode7 = SWIG_AsVal_double(args(4), &val7);
15237  if (!SWIG_IsOK(ecode7)) {
15238  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
15239  }
15240  arg7 = static_cast< PLFLT >(val7);
15241  ecode8 = SWIG_AsVal_double(args(5), &val8);
15242  if (!SWIG_IsOK(ecode8)) {
15243  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
15244  }
15245  arg8 = static_cast< PLFLT >(val8);
15246  ecode9 = SWIG_AsVal_double(args(6), &val9);
15247  if (!SWIG_IsOK(ecode9)) {
15248  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
15249  }
15250  arg9 = static_cast< PLFLT >(val9);
15251  ecode10 = SWIG_AsVal_double(args(7), &val10);
15252  if (!SWIG_IsOK(ecode10)) {
15253  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
15254  }
15255  arg10 = static_cast< PLFLT >(val10);
15256  ecode11 = SWIG_AsVal_double(args(8), &val11);
15257  if (!SWIG_IsOK(ecode11)) {
15258  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
15259  }
15260  arg11 = static_cast< PLFLT >(val11);
15261  {
15262  if ( _n_dims( args(9) ) > 1 )
15263  {
15264  error( "argument must be a scalar or vector" ); SWIG_fail;
15265  }
15266  if ( _dim( args(9), 0 ) != Xlen )
15267  {
15268  error( "argument vectors must be same length" ); SWIG_fail;
15269  }
15270  temp12 = args(9).matrix_value();
15271  arg12 = &temp12( 0, 0 );
15272  }
15273  {
15274  if ( _n_dims( args(10) ) > 1 )
15275  {
15276  error( "argument must be a scalar or vector" ); SWIG_fail;
15277  }
15278  if ( _dim( args(10), 0 ) != Ylen )
15279  {
15280  error( "argument vectors must be same length" ); SWIG_fail;
15281  }
15282  temp13 = args(10).matrix_value();
15283  arg13 = &temp13( 0, 0 );
15284  }
15285  my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15286  _outv = octave_value();
15287  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15288  {
15289 
15290  }
15291  {
15292 
15293  }
15294  {
15295 
15296  }
15297  return _out;
15298  fail:
15299  {
15300 
15301  }
15302  {
15303 
15304  }
15305  {
15306 
15307  }
15308  return octave_value_list();
15309  }
15310  catch(...) {
15311  {
15312 
15313  }
15314  {
15315 
15316  }
15317  {
15318 
15319  }
15320  throw;
15321  }
15322 }
15323 
15324 
15325 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
15326  PLFLT *arg1 = (PLFLT *) 0 ;
15327  PLINT arg2 ;
15328  PLINT arg3 ;
15329  PLFLT arg4 ;
15330  PLFLT arg5 ;
15331  PLFLT arg6 ;
15332  PLFLT arg7 ;
15333  PLFLT arg8 ;
15334  PLFLT arg9 ;
15335  PLFLT arg10 ;
15336  PLFLT arg11 ;
15337  PLFLT *arg12 = (PLFLT *) 0 ;
15338  PLFLT *arg13 = (PLFLT *) 0 ;
15339  Matrix temp1 ;
15340  double val4 ;
15341  int ecode4 = 0 ;
15342  double val5 ;
15343  int ecode5 = 0 ;
15344  double val6 ;
15345  int ecode6 = 0 ;
15346  double val7 ;
15347  int ecode7 = 0 ;
15348  double val8 ;
15349  int ecode8 = 0 ;
15350  double val9 ;
15351  int ecode9 = 0 ;
15352  double val10 ;
15353  int ecode10 = 0 ;
15354  double val11 ;
15355  int ecode11 = 0 ;
15356  Matrix temp12 ;
15357  Matrix temp13 ;
15358  octave_value_list _out;
15359  octave_value_list *_outp=&_out;
15360  octave_value _outv;
15361 
15362  try {
15363  if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
15364  SWIG_fail;
15365  }
15366  {
15367  if ( _n_dims( args(0) ) > 2 )
15368  {
15369  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15370  }
15371  temp1 = args(0).matrix_value();
15372  arg1 = &temp1( 0, 0 );
15373  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15374  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15375  }
15376  ecode4 = SWIG_AsVal_double(args(1), &val4);
15377  if (!SWIG_IsOK(ecode4)) {
15378  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
15379  }
15380  arg4 = static_cast< PLFLT >(val4);
15381  ecode5 = SWIG_AsVal_double(args(2), &val5);
15382  if (!SWIG_IsOK(ecode5)) {
15383  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
15384  }
15385  arg5 = static_cast< PLFLT >(val5);
15386  ecode6 = SWIG_AsVal_double(args(3), &val6);
15387  if (!SWIG_IsOK(ecode6)) {
15388  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
15389  }
15390  arg6 = static_cast< PLFLT >(val6);
15391  ecode7 = SWIG_AsVal_double(args(4), &val7);
15392  if (!SWIG_IsOK(ecode7)) {
15393  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
15394  }
15395  arg7 = static_cast< PLFLT >(val7);
15396  ecode8 = SWIG_AsVal_double(args(5), &val8);
15397  if (!SWIG_IsOK(ecode8)) {
15398  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
15399  }
15400  arg8 = static_cast< PLFLT >(val8);
15401  ecode9 = SWIG_AsVal_double(args(6), &val9);
15402  if (!SWIG_IsOK(ecode9)) {
15403  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
15404  }
15405  arg9 = static_cast< PLFLT >(val9);
15406  ecode10 = SWIG_AsVal_double(args(7), &val10);
15407  if (!SWIG_IsOK(ecode10)) {
15408  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
15409  }
15410  arg10 = static_cast< PLFLT >(val10);
15411  ecode11 = SWIG_AsVal_double(args(8), &val11);
15412  if (!SWIG_IsOK(ecode11)) {
15413  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
15414  }
15415  arg11 = static_cast< PLFLT >(val11);
15416  {
15417  if ( _n_dims( args(9) ) > 2 )
15418  {
15419  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15420  }
15421  temp12 = args(9).matrix_value();
15422  arg12 = &temp12( 0, 0 );
15423  Xlen = (PLINT) ( _dim( args(9), 0 ) );
15424  Ylen = (PLINT) ( _dim( args(9), 1 ) );
15425  }
15426  {
15427  if ( _n_dims( args(10) ) > 2 )
15428  {
15429  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15430  }
15431  temp13 = args(10).matrix_value();
15432  arg13 = &temp13( 0, 0 );
15433  Xlen = (PLINT) ( _dim( args(10), 0 ) );
15434  Ylen = (PLINT) ( _dim( args(10), 1 ) );
15435  }
15436  my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15437  _outv = octave_value();
15438  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15439  {
15440 
15441  }
15442  {
15443 
15444  }
15445  {
15446 
15447  }
15448  return _out;
15449  fail:
15450  {
15451 
15452  }
15453  {
15454 
15455  }
15456  {
15457 
15458  }
15459  return octave_value_list();
15460  }
15461  catch(...) {
15462  {
15463 
15464  }
15465  {
15466 
15467  }
15468  {
15469 
15470  }
15471  throw;
15472  }
15473 }
15474 
15475 
15477  PLFLT *arg1 = (PLFLT *) 0 ;
15478  PLFLT *arg2 = (PLFLT *) 0 ;
15479  PLINT arg3 ;
15480  PLINT arg4 ;
15481  PLFLT arg5 ;
15482  PLFLT arg6 ;
15483  PLFLT arg7 ;
15484  PLFLT arg8 ;
15485  PLINT arg9 ;
15486  PLINT arg10 ;
15487  PLINT arg11 ;
15488  PLFLT arg12 ;
15489  PLFLT arg13 ;
15490  PLINT arg14 ;
15491  PLFLT arg15 ;
15492  PLINT arg16 ;
15493  PLINT *arg17 = (PLINT *) 0 ;
15494  char **arg18 = (char **) 0 ;
15495  PLINT arg19 ;
15496  char **arg20 = (char **) 0 ;
15497  PLFLT *arg21 = (PLFLT *) 0 ;
15498  PLINT *arg22 = (PLINT *) 0 ;
15499  PLINT *arg23 = (PLINT *) 0 ;
15500  PLFLT *arg24 = (PLFLT *) 0 ;
15501  PLFLT temp1 ;
15502  int res1 = SWIG_TMPOBJ ;
15503  PLFLT temp2 ;
15504  int res2 = SWIG_TMPOBJ ;
15505  int val3 ;
15506  int ecode3 = 0 ;
15507  int val4 ;
15508  int ecode4 = 0 ;
15509  double val5 ;
15510  int ecode5 = 0 ;
15511  double val6 ;
15512  int ecode6 = 0 ;
15513  double val7 ;
15514  int ecode7 = 0 ;
15515  double val8 ;
15516  int ecode8 = 0 ;
15517  int val9 ;
15518  int ecode9 = 0 ;
15519  int val10 ;
15520  int ecode10 = 0 ;
15521  int val11 ;
15522  int ecode11 = 0 ;
15523  double val12 ;
15524  int ecode12 = 0 ;
15525  double val13 ;
15526  int ecode13 = 0 ;
15527  int val14 ;
15528  int ecode14 = 0 ;
15529  double val15 ;
15530  int ecode15 = 0 ;
15531  Matrix temp16 ;
15532  Matrix temp21 ;
15533  Matrix temp22 ;
15534  Matrix temp23 ;
15535  Matrix temp24 ;
15536  octave_value_list _out;
15537  octave_value_list *_outp=&_out;
15538  octave_value _outv;
15539 
15540  try {
15541  arg1 = &temp1;
15542  arg2 = &temp2;
15543  if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15544  SWIG_fail;
15545  }
15546  ecode3 = SWIG_AsVal_int(args(0), &val3);
15547  if (!SWIG_IsOK(ecode3)) {
15548  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15549  }
15550  arg3 = static_cast< PLINT >(val3);
15551  ecode4 = SWIG_AsVal_int(args(1), &val4);
15552  if (!SWIG_IsOK(ecode4)) {
15553  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15554  }
15555  arg4 = static_cast< PLINT >(val4);
15556  ecode5 = SWIG_AsVal_double(args(2), &val5);
15557  if (!SWIG_IsOK(ecode5)) {
15558  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15559  }
15560  arg5 = static_cast< PLFLT >(val5);
15561  ecode6 = SWIG_AsVal_double(args(3), &val6);
15562  if (!SWIG_IsOK(ecode6)) {
15563  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15564  }
15565  arg6 = static_cast< PLFLT >(val6);
15566  ecode7 = SWIG_AsVal_double(args(4), &val7);
15567  if (!SWIG_IsOK(ecode7)) {
15568  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15569  }
15570  arg7 = static_cast< PLFLT >(val7);
15571  ecode8 = SWIG_AsVal_double(args(5), &val8);
15572  if (!SWIG_IsOK(ecode8)) {
15573  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15574  }
15575  arg8 = static_cast< PLFLT >(val8);
15576  ecode9 = SWIG_AsVal_int(args(6), &val9);
15577  if (!SWIG_IsOK(ecode9)) {
15578  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15579  }
15580  arg9 = static_cast< PLINT >(val9);
15581  ecode10 = SWIG_AsVal_int(args(7), &val10);
15582  if (!SWIG_IsOK(ecode10)) {
15583  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15584  }
15585  arg10 = static_cast< PLINT >(val10);
15586  ecode11 = SWIG_AsVal_int(args(8), &val11);
15587  if (!SWIG_IsOK(ecode11)) {
15588  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15589  }
15590  arg11 = static_cast< PLINT >(val11);
15591  ecode12 = SWIG_AsVal_double(args(9), &val12);
15592  if (!SWIG_IsOK(ecode12)) {
15593  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15594  }
15595  arg12 = static_cast< PLFLT >(val12);
15596  ecode13 = SWIG_AsVal_double(args(10), &val13);
15597  if (!SWIG_IsOK(ecode13)) {
15598  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15599  }
15600  arg13 = static_cast< PLFLT >(val13);
15601  ecode14 = SWIG_AsVal_int(args(11), &val14);
15602  if (!SWIG_IsOK(ecode14)) {
15603  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15604  }
15605  arg14 = static_cast< PLINT >(val14);
15606  ecode15 = SWIG_AsVal_double(args(12), &val15);
15607  if (!SWIG_IsOK(ecode15)) {
15608  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15609  }
15610  arg15 = static_cast< PLFLT >(val15);
15611  {
15612  if ( _n_dims( args(13) ) > 1 )
15613  {
15614  error( "argument must be a scalar or vector" ); SWIG_fail;
15615  }
15616  arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15617  arg17 = new PLINT[Alen];
15618  temp16 = args(13).matrix_value();
15619  _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15620  }
15621  {
15622  charMatrix temp_matrix;
15623  Cell temp_cell;
15624  char *tmp_cstring;
15625  std::string str;
15626  size_t max_length = 0, non_blank_length;
15627  int i, ifcell;
15628  if ( _n_dims( args(14) ) > 2 )
15629  {
15630  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15631  }
15632 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15633  if ( !args(14).isempty() )
15634 #else
15635  if ( !args(14).is_empty() )
15636 #endif
15637  {
15638  if ( _dim( args(14), 0 ) != Alen )
15639  {
15640  error( "first dimension must be same length as previous vector" ); SWIG_fail;
15641  }
15642  arg18 = new char*[Alen];
15643 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15644  ifcell = args(14).iscell();
15645 #else
15646  ifcell = args(14).is_cell();
15647 #endif
15648  if ( ifcell )
15649  {
15650  temp_cell = args(14).cell_value();
15651  }
15652  else
15653  {
15654  temp_matrix = args(14).char_matrix_value();
15655  // Allow one extra space for null termination.
15656  max_length = _dim( args(14), 1 ) + 1;
15657  }
15658 
15659  for ( i = 0; i < Alen; i++ )
15660  {
15661  // Must copy string to "permanent" location because the string
15662  // location corresponding to tmp_cstring gets
15663  // overwritten for each iteration of loop.
15664  if ( ifcell )
15665  {
15666  if ( temp_cell.elem( i ).is_string() )
15667  {
15668  str = temp_cell.elem( i ).string_value();
15669  // leave room for null termination.
15670  max_length = str.size() + 1;
15671  tmp_cstring = (char *) str.c_str();
15672  }
15673  else
15674  {
15675  // Use null string if user attempts to pass a cell array
15676  // with a non-string element (likely an empty element
15677  // since that should be allowed by the PLplot interface
15678  // if that element is going to be unused).
15679  // leave room for null termination.
15680  max_length = 1;
15681  tmp_cstring = (char *) "";
15682  }
15683  }
15684  else
15685  {
15686  str = temp_matrix.row_as_string( i );
15687  tmp_cstring = (char *) str.c_str();
15688  }
15689  arg18[i] = new char[max_length];
15690  strncpy( arg18[i], tmp_cstring, max_length - 1 );
15691  arg18[i][max_length - 1] = '\0';
15692  // All the trailing blank crapola should not be needed for
15693  // string cell arrays.
15694  if ( !ifcell )
15695  {
15696  // remove trailing-blank padding that is used by the
15697  // charMatrix class to insure all strings in a given
15698  // charMatrix instance have the same length.
15699  // This transformation also removes legitimate trailing
15700  // blanks but there is nothing we can do about that
15701  // for the charMatrix class.
15702 
15703  // Look for trailing nulls first (just in case, although that
15704  // shouldn't happen if charMatrix implemented as documented)
15705  // before looking for trailing blanks.
15706  non_blank_length = max_length - 2;
15707  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15708  {
15709  non_blank_length--;
15710  }
15711  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15712  {
15713  non_blank_length--;
15714  }
15715  arg18[i][non_blank_length + 1] = '\0';
15716  }
15717  }
15718  }
15719  else
15720  {
15721  arg18 = NULL;
15722  }
15723  }
15724  {
15725  charMatrix temp_matrix;
15726  Cell temp_cell;
15727  char *tmp_cstring;
15728  std::string str;
15729  size_t max_length = 0, non_blank_length;
15730  int i, ifcell;
15731  if ( _n_dims( args(15) ) > 2 )
15732  {
15733  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15734  }
15735 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15736  if ( !args(15).isempty() )
15737 #else
15738  if ( !args(15).is_empty() )
15739 #endif
15740  {
15741  Alen = _dim( args(15), 0 );
15742  arg19 = Alen;
15743  arg20 = new char*[Alen];
15744 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15745  ifcell = args(15).iscell();
15746 #else
15747  ifcell = args(15).is_cell();
15748 #endif
15749  if ( ifcell )
15750  {
15751  temp_cell = args(15).cell_value();
15752  }
15753  else
15754  {
15755  temp_matrix = args(15).char_matrix_value();
15756  // Allow one extra space for null termination.
15757  max_length = _dim( args(15), 1 ) + 1;
15758  }
15759 
15760  for ( i = 0; i < Alen; i++ )
15761  {
15762  // Must copy string to "permanent" location because the string
15763  // location corresponding to tmp_cstring gets
15764  // overwritten for each iteration of loop.
15765  if ( ifcell )
15766  {
15767  if ( temp_cell.elem( i ).is_string() )
15768  {
15769  str = temp_cell.elem( i ).string_value();
15770  // leave room for null termination.
15771  max_length = str.size() + 1;
15772  tmp_cstring = (char *) str.c_str();
15773  }
15774  else
15775  {
15776  // Use null string if user attempts to pass a cell array
15777  // with a non-string element (likely an empty element
15778  // since that should be allowed by the PLplot interface
15779  // if that element is going to be unused).
15780  // leave room for null termination.
15781  max_length = 1;
15782  tmp_cstring = (char *) "";
15783  }
15784  }
15785  else
15786  {
15787  str = temp_matrix.row_as_string( i );
15788  tmp_cstring = (char *) str.c_str();
15789  }
15790  arg20[i] = new char[max_length];
15791  strncpy( arg20[i], tmp_cstring, max_length - 1 );
15792  arg20[i][max_length - 1] = '\0';
15793  // All the trailing blank crapola should not be needed for
15794  // string cell arrays.
15795  if ( !ifcell )
15796  {
15797  // remove trailing-blank padding that is used by the
15798  // charMatrix class to insure all strings in a given
15799  // charMatrix instance have the same length.
15800  // This transformation also removes legitimate trailing
15801  // blanks but there is nothing we can do about that
15802  // for the charMatrix class.
15803 
15804  // Look for trailing nulls first (just in case, although that
15805  // shouldn't happen if charMatrix implemented as documented)
15806  // before looking for trailing blanks.
15807  non_blank_length = max_length - 2;
15808  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
15809  {
15810  non_blank_length--;
15811  }
15812  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
15813  {
15814  non_blank_length--;
15815  }
15816  arg20[i][non_blank_length + 1] = '\0';
15817  }
15818  }
15819  }
15820  else
15821  {
15822  arg19 = 0;
15823  arg20 = NULL;
15824  }
15825  }
15826  {
15827  if ( _n_dims( args(16) ) > 1 )
15828  {
15829  error( "argument must be a scalar or vector" ); SWIG_fail;
15830  }
15831  if ( _dim( args(16), 0 ) != Alen )
15832  {
15833  error( "argument vectors must be same length" ); SWIG_fail;
15834  }
15835  temp21 = args(16).matrix_value();
15836  arg21 = &temp21( 0, 0 );
15837  }
15838  {
15839  if ( _n_dims( args(17) ) > 1 )
15840  {
15841  error( "argument must be a scalar or vector" ); SWIG_fail;
15842  }
15843  if ( _dim( args(17), 0 ) != Alen )
15844  {
15845  error( "argument vectors must be same length" ); SWIG_fail;
15846  }
15847  temp22 = args(17).matrix_value();
15848  arg22 = new PLINT[Alen];
15849  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
15850  }
15851  {
15852  int i;
15853  if ( _n_dims( args(18) ) > 1 )
15854  {
15855  error( "argument must be a scalar or vector" ); SWIG_fail;
15856  }
15857  if ( _dim( args(18), 0 ) != Alen )
15858  {
15859  error( "argument vectors must be same length" ); SWIG_fail;
15860  }
15861  Xlen = Alen;
15862  temp23 = args(18).matrix_value();
15863  arg23 = new PLINT[Alen];
15864  _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
15865  Ylen = -1;
15866  for ( i = 0; i < Xlen; i++ )
15867  if ( arg23[i] > Ylen )
15868  Ylen = arg23[i];
15869  }
15870  {
15871  if ( _n_dims( args(19) ) > 2 )
15872  {
15873  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15874  }
15875  if ( _dim( args(19), 0 ) != Xlen )
15876  {
15877  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
15878  }
15879  if ( _dim( args(19), 1 ) != Ylen )
15880  {
15881  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
15882  }
15883  temp24 = args(19).matrix_value();
15884  arg24 = &temp24( 0, 0 );
15885  }
15886  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);
15887  _outv = octave_value();
15888  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15889  if (SWIG_IsTmpObj(res1)) {
15890  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15891  } else {
15892  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15893  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15894  }
15895  if (SWIG_IsTmpObj(res2)) {
15896  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15897  } else {
15898  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15899  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15900  }
15901  {
15902  delete [] arg17;
15903  }
15904  {
15905  int i;
15906  if ( arg18 != NULL )
15907  {
15908  for ( i = 0; i < Alen; i++ )
15909  {
15910  delete[] arg18[i];
15911  }
15912  delete[] arg18;
15913  }
15914  }
15915  {
15916  int i;
15917  if ( arg20 != NULL )
15918  {
15919  for ( i = 0; i < Alen; i++ )
15920  {
15921  delete[] arg20[i];
15922  }
15923  delete[] arg20;
15924  }
15925  }
15926  {
15927 
15928  }
15929  {
15930  delete [] arg22;
15931  }
15932  {
15933  delete [] arg23;
15934  }
15935  {
15936 
15937  }
15938  return _out;
15939  fail:
15940  {
15941  delete [] arg17;
15942  }
15943  {
15944  int i;
15945  if ( arg18 != NULL )
15946  {
15947  for ( i = 0; i < Alen; i++ )
15948  {
15949  delete[] arg18[i];
15950  }
15951  delete[] arg18;
15952  }
15953  }
15954  {
15955  int i;
15956  if ( arg20 != NULL )
15957  {
15958  for ( i = 0; i < Alen; i++ )
15959  {
15960  delete[] arg20[i];
15961  }
15962  delete[] arg20;
15963  }
15964  }
15965  {
15966 
15967  }
15968  {
15969  delete [] arg22;
15970  }
15971  {
15972  delete [] arg23;
15973  }
15974  {
15975 
15976  }
15977  return octave_value_list();
15978  }
15979  catch(...) {
15980  {
15981  delete [] arg17;
15982  }
15983  {
15984  int i;
15985  if ( arg18 != NULL )
15986  {
15987  for ( i = 0; i < Alen; i++ )
15988  {
15989  delete[] arg18[i];
15990  }
15991  delete[] arg18;
15992  }
15993  }
15994  {
15995  int i;
15996  if ( arg20 != NULL )
15997  {
15998  for ( i = 0; i < Alen; i++ )
15999  {
16000  delete[] arg20[i];
16001  }
16002  delete[] arg20;
16003  }
16004  }
16005  {
16006 
16007  }
16008  {
16009  delete [] arg22;
16010  }
16011  {
16012  delete [] arg23;
16013  }
16014  {
16015 
16016  }
16017  throw;
16018  }
16019 }
16020 
16021 
16022 SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
16023  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16024  int arg2 ;
16025  void *argp1 = 0 ;
16026  int res1 = 0 ;
16027  int val2 ;
16028  int ecode2 = 0 ;
16029  octave_value_list _out;
16030  octave_value_list *_outp=&_out;
16031  octave_value _outv;
16032 
16033  try {
16034  if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
16035  SWIG_fail;
16036  }
16037  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16038  if (!SWIG_IsOK(res1)) {
16039  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16040  }
16041  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16042  ecode2 = SWIG_AsVal_int(args(1), &val2);
16043  if (!SWIG_IsOK(ecode2)) {
16044  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
16045  }
16046  arg2 = static_cast< int >(val2);
16047  if (arg1) (arg1)->type = arg2;
16048  _outv = octave_value();
16049  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16050  return _out;
16051  fail:
16052  return octave_value_list();
16053  }
16054  catch(...) {
16055  throw;
16056  }
16057 }
16058 
16059 
16060 SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
16061  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16062  void *argp1 = 0 ;
16063  int res1 = 0 ;
16064  octave_value_list _out;
16065  octave_value_list *_outp=&_out;
16066  octave_value _outv;
16067  int result;
16068 
16069  try {
16070  if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
16071  SWIG_fail;
16072  }
16073  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16074  if (!SWIG_IsOK(res1)) {
16075  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16076  }
16077  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16078  result = (int) ((arg1)->type);
16079  _outv = SWIG_From_int(static_cast< int >(result));
16080  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16081  return _out;
16082  fail:
16083  return octave_value_list();
16084  }
16085  catch(...) {
16086  throw;
16087  }
16088 }
16089 
16090 
16091 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
16092  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16093  unsigned int arg2 ;
16094  void *argp1 = 0 ;
16095  int res1 = 0 ;
16096  unsigned int val2 ;
16097  int ecode2 = 0 ;
16098  octave_value_list _out;
16099  octave_value_list *_outp=&_out;
16100  octave_value _outv;
16101 
16102  try {
16103  if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
16104  SWIG_fail;
16105  }
16106  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16107  if (!SWIG_IsOK(res1)) {
16108  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16109  }
16110  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16111  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16112  if (!SWIG_IsOK(ecode2)) {
16113  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
16114  }
16115  arg2 = static_cast< unsigned int >(val2);
16116  if (arg1) (arg1)->state = arg2;
16117  _outv = octave_value();
16118  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16119  return _out;
16120  fail:
16121  return octave_value_list();
16122  }
16123  catch(...) {
16124  throw;
16125  }
16126 }
16127 
16128 
16129 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
16130  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16131  void *argp1 = 0 ;
16132  int res1 = 0 ;
16133  octave_value_list _out;
16134  octave_value_list *_outp=&_out;
16135  octave_value _outv;
16136  unsigned int result;
16137 
16138  try {
16139  if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
16140  SWIG_fail;
16141  }
16142  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16143  if (!SWIG_IsOK(res1)) {
16144  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16145  }
16146  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16147  result = (unsigned int) ((arg1)->state);
16148  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16149  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16150  return _out;
16151  fail:
16152  return octave_value_list();
16153  }
16154  catch(...) {
16155  throw;
16156  }
16157 }
16158 
16159 
16160 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
16161  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16162  unsigned int arg2 ;
16163  void *argp1 = 0 ;
16164  int res1 = 0 ;
16165  unsigned int val2 ;
16166  int ecode2 = 0 ;
16167  octave_value_list _out;
16168  octave_value_list *_outp=&_out;
16169  octave_value _outv;
16170 
16171  try {
16172  if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
16173  SWIG_fail;
16174  }
16175  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16176  if (!SWIG_IsOK(res1)) {
16177  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16178  }
16179  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16180  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16181  if (!SWIG_IsOK(ecode2)) {
16182  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
16183  }
16184  arg2 = static_cast< unsigned int >(val2);
16185  if (arg1) (arg1)->keysym = arg2;
16186  _outv = octave_value();
16187  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16188  return _out;
16189  fail:
16190  return octave_value_list();
16191  }
16192  catch(...) {
16193  throw;
16194  }
16195 }
16196 
16197 
16198 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
16199  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16200  void *argp1 = 0 ;
16201  int res1 = 0 ;
16202  octave_value_list _out;
16203  octave_value_list *_outp=&_out;
16204  octave_value _outv;
16205  unsigned int result;
16206 
16207  try {
16208  if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
16209  SWIG_fail;
16210  }
16211  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16212  if (!SWIG_IsOK(res1)) {
16213  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16214  }
16215  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16216  result = (unsigned int) ((arg1)->keysym);
16217  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16218  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16219  return _out;
16220  fail:
16221  return octave_value_list();
16222  }
16223  catch(...) {
16224  throw;
16225  }
16226 }
16227 
16228 
16229 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
16230  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16231  unsigned int arg2 ;
16232  void *argp1 = 0 ;
16233  int res1 = 0 ;
16234  unsigned int val2 ;
16235  int ecode2 = 0 ;
16236  octave_value_list _out;
16237  octave_value_list *_outp=&_out;
16238  octave_value _outv;
16239 
16240  try {
16241  if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
16242  SWIG_fail;
16243  }
16244  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16245  if (!SWIG_IsOK(res1)) {
16246  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16247  }
16248  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16249  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16250  if (!SWIG_IsOK(ecode2)) {
16251  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
16252  }
16253  arg2 = static_cast< unsigned int >(val2);
16254  if (arg1) (arg1)->button = arg2;
16255  _outv = octave_value();
16256  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16257  return _out;
16258  fail:
16259  return octave_value_list();
16260  }
16261  catch(...) {
16262  throw;
16263  }
16264 }
16265 
16266 
16267 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
16268  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16269  void *argp1 = 0 ;
16270  int res1 = 0 ;
16271  octave_value_list _out;
16272  octave_value_list *_outp=&_out;
16273  octave_value _outv;
16274  unsigned int result;
16275 
16276  try {
16277  if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
16278  SWIG_fail;
16279  }
16280  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16281  if (!SWIG_IsOK(res1)) {
16282  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16283  }
16284  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16285  result = (unsigned int) ((arg1)->button);
16286  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16287  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16288  return _out;
16289  fail:
16290  return octave_value_list();
16291  }
16292  catch(...) {
16293  throw;
16294  }
16295 }
16296 
16297 
16298 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
16299  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16300  PLINT arg2 ;
16301  void *argp1 = 0 ;
16302  int res1 = 0 ;
16303  int val2 ;
16304  int ecode2 = 0 ;
16305  octave_value_list _out;
16306  octave_value_list *_outp=&_out;
16307  octave_value _outv;
16308 
16309  try {
16310  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
16311  SWIG_fail;
16312  }
16313  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16314  if (!SWIG_IsOK(res1)) {
16315  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16316  }
16317  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16318  ecode2 = SWIG_AsVal_int(args(1), &val2);
16319  if (!SWIG_IsOK(ecode2)) {
16320  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
16321  }
16322  arg2 = static_cast< PLINT >(val2);
16323  if (arg1) (arg1)->subwindow = arg2;
16324  _outv = octave_value();
16325  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16326  return _out;
16327  fail:
16328  return octave_value_list();
16329  }
16330  catch(...) {
16331  throw;
16332  }
16333 }
16334 
16335 
16336 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
16337  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16338  void *argp1 = 0 ;
16339  int res1 = 0 ;
16340  octave_value_list _out;
16341  octave_value_list *_outp=&_out;
16342  octave_value _outv;
16343  PLINT result;
16344 
16345  try {
16346  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
16347  SWIG_fail;
16348  }
16349  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16350  if (!SWIG_IsOK(res1)) {
16351  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16352  }
16353  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16354  result = (PLINT) ((arg1)->subwindow);
16355  _outv = SWIG_From_int(static_cast< int >(result));
16356  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16357  return _out;
16358  fail:
16359  return octave_value_list();
16360  }
16361  catch(...) {
16362  throw;
16363  }
16364 }
16365 
16366 
16367 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
16368  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16369  char *arg2 ;
16370  void *argp1 = 0 ;
16371  int res1 = 0 ;
16372  char temp2[16] ;
16373  int res2 ;
16374  octave_value_list _out;
16375  octave_value_list *_outp=&_out;
16376  octave_value _outv;
16377 
16378  try {
16379  if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
16380  SWIG_fail;
16381  }
16382  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16383  if (!SWIG_IsOK(res1)) {
16384  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16385  }
16386  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16387  res2 = SWIG_AsCharArray(args(1), temp2, 16);
16388  if (!SWIG_IsOK(res2)) {
16389  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
16390  }
16391  arg2 = reinterpret_cast< char * >(temp2);
16392  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
16393  else memset(arg1->string,0,16*sizeof(char));
16394  _outv = octave_value();
16395  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16396  return _out;
16397  fail:
16398  return octave_value_list();
16399  }
16400  catch(...) {
16401  throw;
16402  }
16403 }
16404 
16405 
16406 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
16407  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16408  void *argp1 = 0 ;
16409  int res1 = 0 ;
16410  octave_value_list _out;
16411  octave_value_list *_outp=&_out;
16412  octave_value _outv;
16413  char *result = 0 ;
16414 
16415  try {
16416  if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
16417  SWIG_fail;
16418  }
16419  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16420  if (!SWIG_IsOK(res1)) {
16421  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16422  }
16423  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16424  result = (char *)(char *) ((arg1)->string);
16425  {
16426  size_t size = SWIG_strnlen(result, 16);
16427 
16428 
16429 
16430  _outv = SWIG_FromCharPtrAndSize(result, size);
16431  }
16432  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16433  return _out;
16434  fail:
16435  return octave_value_list();
16436  }
16437  catch(...) {
16438  throw;
16439  }
16440 }
16441 
16442 
16443 SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
16444  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16445  int arg2 ;
16446  void *argp1 = 0 ;
16447  int res1 = 0 ;
16448  int val2 ;
16449  int ecode2 = 0 ;
16450  octave_value_list _out;
16451  octave_value_list *_outp=&_out;
16452  octave_value _outv;
16453 
16454  try {
16455  if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
16456  SWIG_fail;
16457  }
16458  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16459  if (!SWIG_IsOK(res1)) {
16460  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16461  }
16462  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16463  ecode2 = SWIG_AsVal_int(args(1), &val2);
16464  if (!SWIG_IsOK(ecode2)) {
16465  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
16466  }
16467  arg2 = static_cast< int >(val2);
16468  if (arg1) (arg1)->pX = arg2;
16469  _outv = octave_value();
16470  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16471  return _out;
16472  fail:
16473  return octave_value_list();
16474  }
16475  catch(...) {
16476  throw;
16477  }
16478 }
16479 
16480 
16481 SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
16482  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16483  void *argp1 = 0 ;
16484  int res1 = 0 ;
16485  octave_value_list _out;
16486  octave_value_list *_outp=&_out;
16487  octave_value _outv;
16488  int result;
16489 
16490  try {
16491  if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
16492  SWIG_fail;
16493  }
16494  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16495  if (!SWIG_IsOK(res1)) {
16496  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16497  }
16498  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16499  result = (int) ((arg1)->pX);
16500  _outv = SWIG_From_int(static_cast< int >(result));
16501  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16502  return _out;
16503  fail:
16504  return octave_value_list();
16505  }
16506  catch(...) {
16507  throw;
16508  }
16509 }
16510 
16511 
16512 SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
16513  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16514  int arg2 ;
16515  void *argp1 = 0 ;
16516  int res1 = 0 ;
16517  int val2 ;
16518  int ecode2 = 0 ;
16519  octave_value_list _out;
16520  octave_value_list *_outp=&_out;
16521  octave_value _outv;
16522 
16523  try {
16524  if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
16525  SWIG_fail;
16526  }
16527  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16528  if (!SWIG_IsOK(res1)) {
16529  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16530  }
16531  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16532  ecode2 = SWIG_AsVal_int(args(1), &val2);
16533  if (!SWIG_IsOK(ecode2)) {
16534  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
16535  }
16536  arg2 = static_cast< int >(val2);
16537  if (arg1) (arg1)->pY = arg2;
16538  _outv = octave_value();
16539  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16540  return _out;
16541  fail:
16542  return octave_value_list();
16543  }
16544  catch(...) {
16545  throw;
16546  }
16547 }
16548 
16549 
16550 SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
16551  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16552  void *argp1 = 0 ;
16553  int res1 = 0 ;
16554  octave_value_list _out;
16555  octave_value_list *_outp=&_out;
16556  octave_value _outv;
16557  int result;
16558 
16559  try {
16560  if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
16561  SWIG_fail;
16562  }
16563  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16564  if (!SWIG_IsOK(res1)) {
16565  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16566  }
16567  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16568  result = (int) ((arg1)->pY);
16569  _outv = SWIG_From_int(static_cast< int >(result));
16570  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16571  return _out;
16572  fail:
16573  return octave_value_list();
16574  }
16575  catch(...) {
16576  throw;
16577  }
16578 }
16579 
16580 
16581 SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
16582  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16583  PLFLT arg2 ;
16584  void *argp1 = 0 ;
16585  int res1 = 0 ;
16586  double val2 ;
16587  int ecode2 = 0 ;
16588  octave_value_list _out;
16589  octave_value_list *_outp=&_out;
16590  octave_value _outv;
16591 
16592  try {
16593  if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
16594  SWIG_fail;
16595  }
16596  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16597  if (!SWIG_IsOK(res1)) {
16598  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16599  }
16600  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16601  ecode2 = SWIG_AsVal_double(args(1), &val2);
16602  if (!SWIG_IsOK(ecode2)) {
16603  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
16604  }
16605  arg2 = static_cast< PLFLT >(val2);
16606  if (arg1) (arg1)->dX = arg2;
16607  _outv = octave_value();
16608  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16609  return _out;
16610  fail:
16611  return octave_value_list();
16612  }
16613  catch(...) {
16614  throw;
16615  }
16616 }
16617 
16618 
16619 SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
16620  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16621  void *argp1 = 0 ;
16622  int res1 = 0 ;
16623  octave_value_list _out;
16624  octave_value_list *_outp=&_out;
16625  octave_value _outv;
16626  PLFLT result;
16627 
16628  try {
16629  if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
16630  SWIG_fail;
16631  }
16632  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16633  if (!SWIG_IsOK(res1)) {
16634  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16635  }
16636  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16637  result = (PLFLT) ((arg1)->dX);
16638  _outv = SWIG_From_double(static_cast< double >(result));
16639  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16640  return _out;
16641  fail:
16642  return octave_value_list();
16643  }
16644  catch(...) {
16645  throw;
16646  }
16647 }
16648 
16649 
16650 SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16651  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16652  PLFLT arg2 ;
16653  void *argp1 = 0 ;
16654  int res1 = 0 ;
16655  double val2 ;
16656  int ecode2 = 0 ;
16657  octave_value_list _out;
16658  octave_value_list *_outp=&_out;
16659  octave_value _outv;
16660 
16661  try {
16662  if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16663  SWIG_fail;
16664  }
16665  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16666  if (!SWIG_IsOK(res1)) {
16667  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16668  }
16669  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16670  ecode2 = SWIG_AsVal_double(args(1), &val2);
16671  if (!SWIG_IsOK(ecode2)) {
16672  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16673  }
16674  arg2 = static_cast< PLFLT >(val2);
16675  if (arg1) (arg1)->dY = arg2;
16676  _outv = octave_value();
16677  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16678  return _out;
16679  fail:
16680  return octave_value_list();
16681  }
16682  catch(...) {
16683  throw;
16684  }
16685 }
16686 
16687 
16688 SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16689  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16690  void *argp1 = 0 ;
16691  int res1 = 0 ;
16692  octave_value_list _out;
16693  octave_value_list *_outp=&_out;
16694  octave_value _outv;
16695  PLFLT result;
16696 
16697  try {
16698  if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16699  SWIG_fail;
16700  }
16701  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16702  if (!SWIG_IsOK(res1)) {
16703  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16704  }
16705  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16706  result = (PLFLT) ((arg1)->dY);
16707  _outv = SWIG_From_double(static_cast< double >(result));
16708  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16709  return _out;
16710  fail:
16711  return octave_value_list();
16712  }
16713  catch(...) {
16714  throw;
16715  }
16716 }
16717 
16718 
16719 SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16720  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16721  PLFLT arg2 ;
16722  void *argp1 = 0 ;
16723  int res1 = 0 ;
16724  double val2 ;
16725  int ecode2 = 0 ;
16726  octave_value_list _out;
16727  octave_value_list *_outp=&_out;
16728  octave_value _outv;
16729 
16730  try {
16731  if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16732  SWIG_fail;
16733  }
16734  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16735  if (!SWIG_IsOK(res1)) {
16736  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16737  }
16738  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16739  ecode2 = SWIG_AsVal_double(args(1), &val2);
16740  if (!SWIG_IsOK(ecode2)) {
16741  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16742  }
16743  arg2 = static_cast< PLFLT >(val2);
16744  if (arg1) (arg1)->wX = arg2;
16745  _outv = octave_value();
16746  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16747  return _out;
16748  fail:
16749  return octave_value_list();
16750  }
16751  catch(...) {
16752  throw;
16753  }
16754 }
16755 
16756 
16757 SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16758  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16759  void *argp1 = 0 ;
16760  int res1 = 0 ;
16761  octave_value_list _out;
16762  octave_value_list *_outp=&_out;
16763  octave_value _outv;
16764  PLFLT result;
16765 
16766  try {
16767  if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16768  SWIG_fail;
16769  }
16770  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16771  if (!SWIG_IsOK(res1)) {
16772  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16773  }
16774  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16775  result = (PLFLT) ((arg1)->wX);
16776  _outv = SWIG_From_double(static_cast< double >(result));
16777  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16778  return _out;
16779  fail:
16780  return octave_value_list();
16781  }
16782  catch(...) {
16783  throw;
16784  }
16785 }
16786 
16787 
16788 SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
16789  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16790  PLFLT arg2 ;
16791  void *argp1 = 0 ;
16792  int res1 = 0 ;
16793  double val2 ;
16794  int ecode2 = 0 ;
16795  octave_value_list _out;
16796  octave_value_list *_outp=&_out;
16797  octave_value _outv;
16798 
16799  try {
16800  if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
16801  SWIG_fail;
16802  }
16803  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16804  if (!SWIG_IsOK(res1)) {
16805  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16806  }
16807  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16808  ecode2 = SWIG_AsVal_double(args(1), &val2);
16809  if (!SWIG_IsOK(ecode2)) {
16810  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
16811  }
16812  arg2 = static_cast< PLFLT >(val2);
16813  if (arg1) (arg1)->wY = arg2;
16814  _outv = octave_value();
16815  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16816  return _out;
16817  fail:
16818  return octave_value_list();
16819  }
16820  catch(...) {
16821  throw;
16822  }
16823 }
16824 
16825 
16826 SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
16827  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16828  void *argp1 = 0 ;
16829  int res1 = 0 ;
16830  octave_value_list _out;
16831  octave_value_list *_outp=&_out;
16832  octave_value _outv;
16833  PLFLT result;
16834 
16835  try {
16836  if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
16837  SWIG_fail;
16838  }
16839  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16840  if (!SWIG_IsOK(res1)) {
16841  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16842  }
16843  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16844  result = (PLFLT) ((arg1)->wY);
16845  _outv = SWIG_From_double(static_cast< double >(result));
16846  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16847  return _out;
16848  fail:
16849  return octave_value_list();
16850  }
16851  catch(...) {
16852  throw;
16853  }
16854 }
16855 
16856 
16857 SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
16858  octave_value_list _out;
16859  octave_value_list *_outp=&_out;
16860  octave_value _outv;
16861  PLGraphicsIn *result = 0 ;
16862 
16863  try {
16864  if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
16865  SWIG_fail;
16866  }
16867  result = (PLGraphicsIn *)new PLGraphicsIn();
16869  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16870  return _out;
16871  fail:
16872  return octave_value_list();
16873  }
16874  catch(...) {
16875  throw;
16876  }
16877 }
16878 
16879 
16880 SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
16881  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16882  void *argp1 = 0 ;
16883  int res1 = 0 ;
16884  octave_value_list _out;
16885  octave_value_list *_outp=&_out;
16886  octave_value _outv;
16887 
16888  try {
16889  if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
16890  SWIG_fail;
16891  }
16892  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
16893  if (!SWIG_IsOK(res1)) {
16894  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16895  }
16896  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16897  delete arg1;
16898  _outv = octave_value();
16899  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16900  return _out;
16901  fail:
16902  return octave_value_list();
16903  }
16904  catch(...) {
16905  throw;
16906  }
16907 }
16908 
16909 
16923 {0,0,0,0,0,0}
16924 };
16925 static const char *swig_PLGraphicsIn_base_names[] = {0};
16928 
16930  PLINT arg1 ;
16931  PLINT arg2 ;
16932  int val1 ;
16933  int ecode1 = 0 ;
16934  int val2 ;
16935  int ecode2 = 0 ;
16936  octave_value_list _out;
16937  octave_value_list *_outp=&_out;
16938  octave_value _outv;
16939 
16940  try {
16941  if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
16942  SWIG_fail;
16943  }
16944  ecode1 = SWIG_AsVal_int(args(0), &val1);
16945  if (!SWIG_IsOK(ecode1)) {
16946  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
16947  }
16948  arg1 = static_cast< PLINT >(val1);
16949  ecode2 = SWIG_AsVal_int(args(1), &val2);
16950  if (!SWIG_IsOK(ecode2)) {
16951  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
16952  }
16953  arg2 = static_cast< PLINT >(val2);
16954  pl_setcontlabelformat(arg1,arg2);
16955  _outv = octave_value();
16956  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16957  return _out;
16958  fail:
16959  return octave_value_list();
16960  }
16961  catch(...) {
16962  throw;
16963  }
16964 }
16965 
16966 
16968  PLFLT arg1 ;
16969  PLFLT arg2 ;
16970  PLFLT arg3 ;
16971  PLINT arg4 ;
16972  double val1 ;
16973  int ecode1 = 0 ;
16974  double val2 ;
16975  int ecode2 = 0 ;
16976  double val3 ;
16977  int ecode3 = 0 ;
16978  int val4 ;
16979  int ecode4 = 0 ;
16980  octave_value_list _out;
16981  octave_value_list *_outp=&_out;
16982  octave_value _outv;
16983 
16984  try {
16985  if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
16986  SWIG_fail;
16987  }
16988  ecode1 = SWIG_AsVal_double(args(0), &val1);
16989  if (!SWIG_IsOK(ecode1)) {
16990  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
16991  }
16992  arg1 = static_cast< PLFLT >(val1);
16993  ecode2 = SWIG_AsVal_double(args(1), &val2);
16994  if (!SWIG_IsOK(ecode2)) {
16995  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
16996  }
16997  arg2 = static_cast< PLFLT >(val2);
16998  ecode3 = SWIG_AsVal_double(args(2), &val3);
16999  if (!SWIG_IsOK(ecode3)) {
17000  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
17001  }
17002  arg3 = static_cast< PLFLT >(val3);
17003  ecode4 = SWIG_AsVal_int(args(3), &val4);
17004  if (!SWIG_IsOK(ecode4)) {
17005  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
17006  }
17007  arg4 = static_cast< PLINT >(val4);
17008  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
17009  _outv = octave_value();
17010  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17011  return _out;
17012  fail:
17013  return octave_value_list();
17014  }
17015  catch(...) {
17016  throw;
17017  }
17018 }
17019 
17020 
17022  PLINT arg1 ;
17023  int val1 ;
17024  int ecode1 = 0 ;
17025  octave_value_list _out;
17026  octave_value_list *_outp=&_out;
17027  octave_value _outv;
17028 
17029  try {
17030  if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
17031  SWIG_fail;
17032  }
17033  ecode1 = SWIG_AsVal_int(args(0), &val1);
17034  if (!SWIG_IsOK(ecode1)) {
17035  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
17036  }
17037  arg1 = static_cast< PLINT >(val1);
17038  pladv(arg1);
17039  _outv = octave_value();
17040  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17041  return _out;
17042  fail:
17043  return octave_value_list();
17044  }
17045  catch(...) {
17046  throw;
17047  }
17048 }
17049 
17050 
17052  PLFLT arg1 ;
17053  PLFLT arg2 ;
17054  PLFLT arg3 ;
17055  PLFLT arg4 ;
17056  PLFLT arg5 ;
17057  PLFLT arg6 ;
17058  PLFLT arg7 ;
17059  PLBOOL arg8 ;
17060  double val1 ;
17061  int ecode1 = 0 ;
17062  double val2 ;
17063  int ecode2 = 0 ;
17064  double val3 ;
17065  int ecode3 = 0 ;
17066  double val4 ;
17067  int ecode4 = 0 ;
17068  double val5 ;
17069  int ecode5 = 0 ;
17070  double val6 ;
17071  int ecode6 = 0 ;
17072  double val7 ;
17073  int ecode7 = 0 ;
17074  int val8 ;
17075  int ecode8 = 0 ;
17076  octave_value_list _out;
17077  octave_value_list *_outp=&_out;
17078  octave_value _outv;
17079 
17080  try {
17081  if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
17082  SWIG_fail;
17083  }
17084  ecode1 = SWIG_AsVal_double(args(0), &val1);
17085  if (!SWIG_IsOK(ecode1)) {
17086  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
17087  }
17088  arg1 = static_cast< PLFLT >(val1);
17089  ecode2 = SWIG_AsVal_double(args(1), &val2);
17090  if (!SWIG_IsOK(ecode2)) {
17091  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
17092  }
17093  arg2 = static_cast< PLFLT >(val2);
17094  ecode3 = SWIG_AsVal_double(args(2), &val3);
17095  if (!SWIG_IsOK(ecode3)) {
17096  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
17097  }
17098  arg3 = static_cast< PLFLT >(val3);
17099  ecode4 = SWIG_AsVal_double(args(3), &val4);
17100  if (!SWIG_IsOK(ecode4)) {
17101  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
17102  }
17103  arg4 = static_cast< PLFLT >(val4);
17104  ecode5 = SWIG_AsVal_double(args(4), &val5);
17105  if (!SWIG_IsOK(ecode5)) {
17106  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
17107  }
17108  arg5 = static_cast< PLFLT >(val5);
17109  ecode6 = SWIG_AsVal_double(args(5), &val6);
17110  if (!SWIG_IsOK(ecode6)) {
17111  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
17112  }
17113  arg6 = static_cast< PLFLT >(val6);
17114  ecode7 = SWIG_AsVal_double(args(6), &val7);
17115  if (!SWIG_IsOK(ecode7)) {
17116  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
17117  }
17118  arg7 = static_cast< PLFLT >(val7);
17119  ecode8 = SWIG_AsVal_int(args(7), &val8);
17120  if (!SWIG_IsOK(ecode8)) {
17121  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
17122  }
17123  arg8 = static_cast< PLBOOL >(val8);
17124  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17125  _outv = octave_value();
17126  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17127  return _out;
17128  fail:
17129  return octave_value_list();
17130  }
17131  catch(...) {
17132  throw;
17133  }
17134 }
17135 
17136 
17138  PLFLT arg1 ;
17139  PLFLT arg2 ;
17140  char *arg3 = (char *) 0 ;
17141  PLFLT arg4 ;
17142  PLINT arg5 ;
17143  char *arg6 = (char *) 0 ;
17144  PLFLT arg7 ;
17145  PLINT arg8 ;
17146  double val1 ;
17147  int ecode1 = 0 ;
17148  double val2 ;
17149  int ecode2 = 0 ;
17150  int res3 ;
17151  char *buf3 = 0 ;
17152  int alloc3 = 0 ;
17153  double val4 ;
17154  int ecode4 = 0 ;
17155  int val5 ;
17156  int ecode5 = 0 ;
17157  int res6 ;
17158  char *buf6 = 0 ;
17159  int alloc6 = 0 ;
17160  double val7 ;
17161  int ecode7 = 0 ;
17162  int val8 ;
17163  int ecode8 = 0 ;
17164  octave_value_list _out;
17165  octave_value_list *_outp=&_out;
17166  octave_value _outv;
17167 
17168  try {
17169  if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
17170  SWIG_fail;
17171  }
17172  ecode1 = SWIG_AsVal_double(args(0), &val1);
17173  if (!SWIG_IsOK(ecode1)) {
17174  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
17175  }
17176  arg1 = static_cast< PLFLT >(val1);
17177  ecode2 = SWIG_AsVal_double(args(1), &val2);
17178  if (!SWIG_IsOK(ecode2)) {
17179  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
17180  }
17181  arg2 = static_cast< PLFLT >(val2);
17182  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
17183  if (!SWIG_IsOK(res3)) {
17184  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
17185  }
17186  arg3 = reinterpret_cast< char * >(buf3);
17187  ecode4 = SWIG_AsVal_double(args(3), &val4);
17188  if (!SWIG_IsOK(ecode4)) {
17189  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
17190  }
17191  arg4 = static_cast< PLFLT >(val4);
17192  ecode5 = SWIG_AsVal_int(args(4), &val5);
17193  if (!SWIG_IsOK(ecode5)) {
17194  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
17195  }
17196  arg5 = static_cast< PLINT >(val5);
17197  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17198  if (!SWIG_IsOK(res6)) {
17199  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
17200  }
17201  arg6 = reinterpret_cast< char * >(buf6);
17202  ecode7 = SWIG_AsVal_double(args(6), &val7);
17203  if (!SWIG_IsOK(ecode7)) {
17204  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
17205  }
17206  arg7 = static_cast< PLFLT >(val7);
17207  ecode8 = SWIG_AsVal_int(args(7), &val8);
17208  if (!SWIG_IsOK(ecode8)) {
17209  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
17210  }
17211  arg8 = static_cast< PLINT >(val8);
17212  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
17213  _outv = octave_value();
17214  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17215  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17216  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17217  return _out;
17218  fail:
17219  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17220  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17221  return octave_value_list();
17222  }
17223  catch(...) {
17224  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17225  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17226  throw;
17227  }
17228 }
17229 
17230 
17232  PLINT arg1 ;
17233  PLFLT *arg2 = (PLFLT *) 0 ;
17234  PLFLT *arg3 = (PLFLT *) 0 ;
17235  PLINT arg4 ;
17236  Matrix temp1 ;
17237  Matrix temp3 ;
17238  int val4 ;
17239  int ecode4 = 0 ;
17240  octave_value_list _out;
17241  octave_value_list *_outp=&_out;
17242  octave_value _outv;
17243 
17244  try {
17245  if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
17246  SWIG_fail;
17247  }
17248  {
17249  if ( _n_dims( args(0) ) > 1 )
17250  {
17251  error( "argument must be a scalar or vector" ); SWIG_fail;
17252  }
17253  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17254  temp1 = args(0).matrix_value();
17255  arg2 = &temp1( 0, 0 );
17256  }
17257  {
17258  if ( _n_dims( args(1) ) > 1 )
17259  {
17260  error( "argument must be a scalar or vector" ); SWIG_fail;
17261  }
17262  if ( _dim( args(1), 0 ) != Alen )
17263  {
17264  error( "argument vectors must be same length" ); SWIG_fail;
17265  }
17266  temp3 = args(1).matrix_value();
17267  arg3 = &temp3( 0, 0 );
17268  }
17269  ecode4 = SWIG_AsVal_int(args(2), &val4);
17270  if (!SWIG_IsOK(ecode4)) {
17271  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
17272  }
17273  arg4 = static_cast< PLINT >(val4);
17274  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
17275  _outv = octave_value();
17276  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17277  {
17278 
17279  }
17280  {
17281 
17282  }
17283  return _out;
17284  fail:
17285  {
17286 
17287  }
17288  {
17289 
17290  }
17291  return octave_value_list();
17292  }
17293  catch(...) {
17294  {
17295 
17296  }
17297  {
17298 
17299  }
17300  throw;
17301  }
17302 }
17303 
17304 
17306  PLINT *arg1 = (PLINT *) 0 ;
17307  PLINT *arg2 = (PLINT *) 0 ;
17308  PLINT *arg3 = (PLINT *) 0 ;
17309  PLINT *arg4 = (PLINT *) 0 ;
17310  PLINT *arg5 = (PLINT *) 0 ;
17311  PLFLT *arg6 = (PLFLT *) 0 ;
17312  PLFLT arg7 ;
17313  PLINT temp1 ;
17314  int res1 = SWIG_TMPOBJ ;
17315  PLINT temp2 ;
17316  int res2 = SWIG_TMPOBJ ;
17317  PLINT temp3 ;
17318  int res3 = SWIG_TMPOBJ ;
17319  PLINT temp4 ;
17320  int res4 = SWIG_TMPOBJ ;
17321  PLINT temp5 ;
17322  int res5 = SWIG_TMPOBJ ;
17323  PLFLT temp6 ;
17324  int res6 = SWIG_TMPOBJ ;
17325  double val7 ;
17326  int ecode7 = 0 ;
17327  octave_value_list _out;
17328  octave_value_list *_outp=&_out;
17329  octave_value _outv;
17330 
17331  try {
17332  arg1 = &temp1;
17333  arg2 = &temp2;
17334  arg3 = &temp3;
17335  arg4 = &temp4;
17336  arg5 = &temp5;
17337  arg6 = &temp6;
17338  if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
17339  SWIG_fail;
17340  }
17341  ecode7 = SWIG_AsVal_double(args(0), &val7);
17342  if (!SWIG_IsOK(ecode7)) {
17343  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
17344  }
17345  arg7 = static_cast< PLFLT >(val7);
17346  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17347  _outv = octave_value();
17348  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17349  if (SWIG_IsTmpObj(res1)) {
17350  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17351  } else {
17352  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17353  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17354  }
17355  if (SWIG_IsTmpObj(res2)) {
17356  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17357  } else {
17358  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17359  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17360  }
17361  if (SWIG_IsTmpObj(res3)) {
17362  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17363  } else {
17364  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17365  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17366  }
17367  if (SWIG_IsTmpObj(res4)) {
17368  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17369  } else {
17370  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17371  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17372  }
17373  if (SWIG_IsTmpObj(res5)) {
17374  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17375  } else {
17376  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17377  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17378  }
17379  if (SWIG_IsTmpObj(res6)) {
17380  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17381  } else {
17382  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17383  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17384  }
17385  return _out;
17386  fail:
17387  return octave_value_list();
17388  }
17389  catch(...) {
17390  throw;
17391  }
17392 }
17393 
17394 
17396  octave_value_list _out;
17397  octave_value_list *_outp=&_out;
17398  octave_value _outv;
17399 
17400  try {
17401  if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
17402  SWIG_fail;
17403  }
17404  plbop();
17405  _outv = octave_value();
17406  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17407  return _out;
17408  fail:
17409  return octave_value_list();
17410  }
17411  catch(...) {
17412  throw;
17413  }
17414 }
17415 
17416 
17418  char *arg1 = (char *) 0 ;
17419  PLFLT arg2 ;
17420  PLINT arg3 ;
17421  char *arg4 = (char *) 0 ;
17422  PLFLT arg5 ;
17423  PLINT arg6 ;
17424  int res1 ;
17425  char *buf1 = 0 ;
17426  int alloc1 = 0 ;
17427  double val2 ;
17428  int ecode2 = 0 ;
17429  int val3 ;
17430  int ecode3 = 0 ;
17431  int res4 ;
17432  char *buf4 = 0 ;
17433  int alloc4 = 0 ;
17434  double val5 ;
17435  int ecode5 = 0 ;
17436  int val6 ;
17437  int ecode6 = 0 ;
17438  octave_value_list _out;
17439  octave_value_list *_outp=&_out;
17440  octave_value _outv;
17441 
17442  try {
17443  if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
17444  SWIG_fail;
17445  }
17446  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17447  if (!SWIG_IsOK(res1)) {
17448  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
17449  }
17450  arg1 = reinterpret_cast< char * >(buf1);
17451  ecode2 = SWIG_AsVal_double(args(1), &val2);
17452  if (!SWIG_IsOK(ecode2)) {
17453  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
17454  }
17455  arg2 = static_cast< PLFLT >(val2);
17456  ecode3 = SWIG_AsVal_int(args(2), &val3);
17457  if (!SWIG_IsOK(ecode3)) {
17458  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
17459  }
17460  arg3 = static_cast< PLINT >(val3);
17461  res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
17462  if (!SWIG_IsOK(res4)) {
17463  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
17464  }
17465  arg4 = reinterpret_cast< char * >(buf4);
17466  ecode5 = SWIG_AsVal_double(args(4), &val5);
17467  if (!SWIG_IsOK(ecode5)) {
17468  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
17469  }
17470  arg5 = static_cast< PLFLT >(val5);
17471  ecode6 = SWIG_AsVal_int(args(5), &val6);
17472  if (!SWIG_IsOK(ecode6)) {
17473  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
17474  }
17475  arg6 = static_cast< PLINT >(val6);
17476  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
17477  _outv = octave_value();
17478  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17479  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17480  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17481  return _out;
17482  fail:
17483  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17484  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17485  return octave_value_list();
17486  }
17487  catch(...) {
17488  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17489  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17490  throw;
17491  }
17492 }
17493 
17494 
17496  char *arg1 = (char *) 0 ;
17497  char *arg2 = (char *) 0 ;
17498  PLFLT arg3 ;
17499  PLINT arg4 ;
17500  char *arg5 = (char *) 0 ;
17501  char *arg6 = (char *) 0 ;
17502  PLFLT arg7 ;
17503  PLINT arg8 ;
17504  char *arg9 = (char *) 0 ;
17505  char *arg10 = (char *) 0 ;
17506  PLFLT arg11 ;
17507  PLINT arg12 ;
17508  int res1 ;
17509  char *buf1 = 0 ;
17510  int alloc1 = 0 ;
17511  int res2 ;
17512  char *buf2 = 0 ;
17513  int alloc2 = 0 ;
17514  double val3 ;
17515  int ecode3 = 0 ;
17516  int val4 ;
17517  int ecode4 = 0 ;
17518  int res5 ;
17519  char *buf5 = 0 ;
17520  int alloc5 = 0 ;
17521  int res6 ;
17522  char *buf6 = 0 ;
17523  int alloc6 = 0 ;
17524  double val7 ;
17525  int ecode7 = 0 ;
17526  int val8 ;
17527  int ecode8 = 0 ;
17528  int res9 ;
17529  char *buf9 = 0 ;
17530  int alloc9 = 0 ;
17531  int res10 ;
17532  char *buf10 = 0 ;
17533  int alloc10 = 0 ;
17534  double val11 ;
17535  int ecode11 = 0 ;
17536  int val12 ;
17537  int ecode12 = 0 ;
17538  octave_value_list _out;
17539  octave_value_list *_outp=&_out;
17540  octave_value _outv;
17541 
17542  try {
17543  if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
17544  SWIG_fail;
17545  }
17546  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17547  if (!SWIG_IsOK(res1)) {
17548  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
17549  }
17550  arg1 = reinterpret_cast< char * >(buf1);
17551  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
17552  if (!SWIG_IsOK(res2)) {
17553  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
17554  }
17555  arg2 = reinterpret_cast< char * >(buf2);
17556  ecode3 = SWIG_AsVal_double(args(2), &val3);
17557  if (!SWIG_IsOK(ecode3)) {
17558  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
17559  }
17560  arg3 = static_cast< PLFLT >(val3);
17561  ecode4 = SWIG_AsVal_int(args(3), &val4);
17562  if (!SWIG_IsOK(ecode4)) {
17563  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
17564  }
17565  arg4 = static_cast< PLINT >(val4);
17566  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17567  if (!SWIG_IsOK(res5)) {
17568  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
17569  }
17570  arg5 = reinterpret_cast< char * >(buf5);
17571  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17572  if (!SWIG_IsOK(res6)) {
17573  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
17574  }
17575  arg6 = reinterpret_cast< char * >(buf6);
17576  ecode7 = SWIG_AsVal_double(args(6), &val7);
17577  if (!SWIG_IsOK(ecode7)) {
17578  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
17579  }
17580  arg7 = static_cast< PLFLT >(val7);
17581  ecode8 = SWIG_AsVal_int(args(7), &val8);
17582  if (!SWIG_IsOK(ecode8)) {
17583  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
17584  }
17585  arg8 = static_cast< PLINT >(val8);
17586  res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
17587  if (!SWIG_IsOK(res9)) {
17588  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
17589  }
17590  arg9 = reinterpret_cast< char * >(buf9);
17591  res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
17592  if (!SWIG_IsOK(res10)) {
17593  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
17594  }
17595  arg10 = reinterpret_cast< char * >(buf10);
17596  ecode11 = SWIG_AsVal_double(args(10), &val11);
17597  if (!SWIG_IsOK(ecode11)) {
17598  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
17599  }
17600  arg11 = static_cast< PLFLT >(val11);
17601  ecode12 = SWIG_AsVal_int(args(11), &val12);
17602  if (!SWIG_IsOK(ecode12)) {
17603  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
17604  }
17605  arg12 = static_cast< PLINT >(val12);
17606  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);
17607  _outv = octave_value();
17608  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17609  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17610  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17611  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17612  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17613  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17614  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17615  return _out;
17616  fail:
17617  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17618  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17619  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17620  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17621  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17622  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17623  return octave_value_list();
17624  }
17625  catch(...) {
17626  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17627  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17628  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17629  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17630  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17631  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17632  throw;
17633  }
17634 }
17635 
17636 
17638  PLFLT arg1 ;
17639  PLFLT arg2 ;
17640  PLFLT *arg3 = (PLFLT *) 0 ;
17641  PLFLT *arg4 = (PLFLT *) 0 ;
17642  PLINT *arg5 = (PLINT *) 0 ;
17643  double val1 ;
17644  int ecode1 = 0 ;
17645  double val2 ;
17646  int ecode2 = 0 ;
17647  PLFLT temp3 ;
17648  int res3 = SWIG_TMPOBJ ;
17649  PLFLT temp4 ;
17650  int res4 = SWIG_TMPOBJ ;
17651  PLINT temp5 ;
17652  int res5 = SWIG_TMPOBJ ;
17653  octave_value_list _out;
17654  octave_value_list *_outp=&_out;
17655  octave_value _outv;
17656 
17657  try {
17658  arg3 = &temp3;
17659  arg4 = &temp4;
17660  arg5 = &temp5;
17661  if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
17662  SWIG_fail;
17663  }
17664  ecode1 = SWIG_AsVal_double(args(0), &val1);
17665  if (!SWIG_IsOK(ecode1)) {
17666  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
17667  }
17668  arg1 = static_cast< PLFLT >(val1);
17669  ecode2 = SWIG_AsVal_double(args(1), &val2);
17670  if (!SWIG_IsOK(ecode2)) {
17671  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
17672  }
17673  arg2 = static_cast< PLFLT >(val2);
17674  plcalc_world(arg1,arg2,arg3,arg4,arg5);
17675  _outv = octave_value();
17676  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17677  if (SWIG_IsTmpObj(res3)) {
17678  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17679  } else {
17680  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17681  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17682  }
17683  if (SWIG_IsTmpObj(res4)) {
17684  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17685  } else {
17686  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17687  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17688  }
17689  if (SWIG_IsTmpObj(res5)) {
17690  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17691  } else {
17692  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17693  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17694  }
17695  return _out;
17696  fail:
17697  return octave_value_list();
17698  }
17699  catch(...) {
17700  throw;
17701  }
17702 }
17703 
17704 
17706  octave_value_list _out;
17707  octave_value_list *_outp=&_out;
17708  octave_value _outv;
17709 
17710  try {
17711  if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
17712  SWIG_fail;
17713  }
17714  plclear();
17715  _outv = octave_value();
17716  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17717  return _out;
17718  fail:
17719  return octave_value_list();
17720  }
17721  catch(...) {
17722  throw;
17723  }
17724 }
17725 
17726 
17728  PLINT arg1 ;
17729  int val1 ;
17730  int ecode1 = 0 ;
17731  octave_value_list _out;
17732  octave_value_list *_outp=&_out;
17733  octave_value _outv;
17734 
17735  try {
17736  if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
17737  SWIG_fail;
17738  }
17739  ecode1 = SWIG_AsVal_int(args(0), &val1);
17740  if (!SWIG_IsOK(ecode1)) {
17741  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
17742  }
17743  arg1 = static_cast< PLINT >(val1);
17744  plcol0(arg1);
17745  _outv = octave_value();
17746  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17747  return _out;
17748  fail:
17749  return octave_value_list();
17750  }
17751  catch(...) {
17752  throw;
17753  }
17754 }
17755 
17756 
17758  PLFLT arg1 ;
17759  double val1 ;
17760  int ecode1 = 0 ;
17761  octave_value_list _out;
17762  octave_value_list *_outp=&_out;
17763  octave_value _outv;
17764 
17765  try {
17766  if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17767  SWIG_fail;
17768  }
17769  ecode1 = SWIG_AsVal_double(args(0), &val1);
17770  if (!SWIG_IsOK(ecode1)) {
17771  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17772  }
17773  arg1 = static_cast< PLFLT >(val1);
17774  plcol1(arg1);
17775  _outv = octave_value();
17776  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17777  return _out;
17778  fail:
17779  return octave_value_list();
17780  }
17781  catch(...) {
17782  throw;
17783  }
17784 }
17785 
17786 
17788  PLFLT arg1 ;
17789  PLFLT arg2 ;
17790  PLFLT arg3 ;
17791  PLINT arg4 ;
17792  PLBOOL arg5 ;
17793  PLINT arg6 ;
17794  PLINT arg7 ;
17795  PLINT arg8 ;
17796  PLINT arg9 ;
17797  PLINT arg10 ;
17798  PLFLT arg11 ;
17799  double val1 ;
17800  int ecode1 = 0 ;
17801  double val2 ;
17802  int ecode2 = 0 ;
17803  double val3 ;
17804  int ecode3 = 0 ;
17805  int val4 ;
17806  int ecode4 = 0 ;
17807  int val5 ;
17808  int ecode5 = 0 ;
17809  int val6 ;
17810  int ecode6 = 0 ;
17811  int val7 ;
17812  int ecode7 = 0 ;
17813  int val8 ;
17814  int ecode8 = 0 ;
17815  int val9 ;
17816  int ecode9 = 0 ;
17817  int val10 ;
17818  int ecode10 = 0 ;
17819  double val11 ;
17820  int ecode11 = 0 ;
17821  octave_value_list _out;
17822  octave_value_list *_outp=&_out;
17823  octave_value _outv;
17824 
17825  try {
17826  if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
17827  SWIG_fail;
17828  }
17829  ecode1 = SWIG_AsVal_double(args(0), &val1);
17830  if (!SWIG_IsOK(ecode1)) {
17831  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
17832  }
17833  arg1 = static_cast< PLFLT >(val1);
17834  ecode2 = SWIG_AsVal_double(args(1), &val2);
17835  if (!SWIG_IsOK(ecode2)) {
17836  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
17837  }
17838  arg2 = static_cast< PLFLT >(val2);
17839  ecode3 = SWIG_AsVal_double(args(2), &val3);
17840  if (!SWIG_IsOK(ecode3)) {
17841  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
17842  }
17843  arg3 = static_cast< PLFLT >(val3);
17844  ecode4 = SWIG_AsVal_int(args(3), &val4);
17845  if (!SWIG_IsOK(ecode4)) {
17846  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
17847  }
17848  arg4 = static_cast< PLINT >(val4);
17849  ecode5 = SWIG_AsVal_int(args(4), &val5);
17850  if (!SWIG_IsOK(ecode5)) {
17851  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
17852  }
17853  arg5 = static_cast< PLBOOL >(val5);
17854  ecode6 = SWIG_AsVal_int(args(5), &val6);
17855  if (!SWIG_IsOK(ecode6)) {
17856  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
17857  }
17858  arg6 = static_cast< PLINT >(val6);
17859  ecode7 = SWIG_AsVal_int(args(6), &val7);
17860  if (!SWIG_IsOK(ecode7)) {
17861  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
17862  }
17863  arg7 = static_cast< PLINT >(val7);
17864  ecode8 = SWIG_AsVal_int(args(7), &val8);
17865  if (!SWIG_IsOK(ecode8)) {
17866  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
17867  }
17868  arg8 = static_cast< PLINT >(val8);
17869  ecode9 = SWIG_AsVal_int(args(8), &val9);
17870  if (!SWIG_IsOK(ecode9)) {
17871  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
17872  }
17873  arg9 = static_cast< PLINT >(val9);
17874  ecode10 = SWIG_AsVal_int(args(9), &val10);
17875  if (!SWIG_IsOK(ecode10)) {
17876  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
17877  }
17878  arg10 = static_cast< PLINT >(val10);
17879  ecode11 = SWIG_AsVal_double(args(10), &val11);
17880  if (!SWIG_IsOK(ecode11)) {
17881  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
17882  }
17883  arg11 = static_cast< PLFLT >(val11);
17884  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
17885  _outv = octave_value();
17886  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17887  return _out;
17888  fail:
17889  return octave_value_list();
17890  }
17891  catch(...) {
17892  throw;
17893  }
17894 }
17895 
17896 
17898  PLINT arg1 ;
17899  PLINT arg2 ;
17900  PLINT arg3 ;
17901  PLINT arg4 ;
17902  PLINT arg5 ;
17903  PLFLT arg6 ;
17904  PLFLT *arg7 = (PLFLT *) 0 ;
17905  int val1 ;
17906  int ecode1 = 0 ;
17907  int val2 ;
17908  int ecode2 = 0 ;
17909  int val3 ;
17910  int ecode3 = 0 ;
17911  int val4 ;
17912  int ecode4 = 0 ;
17913  int val5 ;
17914  int ecode5 = 0 ;
17915  double val6 ;
17916  int ecode6 = 0 ;
17917  PLFLT temp7 ;
17918  int res7 = SWIG_TMPOBJ ;
17919  octave_value_list _out;
17920  octave_value_list *_outp=&_out;
17921  octave_value _outv;
17922 
17923  try {
17924  arg7 = &temp7;
17925  if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
17926  SWIG_fail;
17927  }
17928  ecode1 = SWIG_AsVal_int(args(0), &val1);
17929  if (!SWIG_IsOK(ecode1)) {
17930  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
17931  }
17932  arg1 = static_cast< PLINT >(val1);
17933  ecode2 = SWIG_AsVal_int(args(1), &val2);
17934  if (!SWIG_IsOK(ecode2)) {
17935  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
17936  }
17937  arg2 = static_cast< PLINT >(val2);
17938  ecode3 = SWIG_AsVal_int(args(2), &val3);
17939  if (!SWIG_IsOK(ecode3)) {
17940  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
17941  }
17942  arg3 = static_cast< PLINT >(val3);
17943  ecode4 = SWIG_AsVal_int(args(3), &val4);
17944  if (!SWIG_IsOK(ecode4)) {
17945  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
17946  }
17947  arg4 = static_cast< PLINT >(val4);
17948  ecode5 = SWIG_AsVal_int(args(4), &val5);
17949  if (!SWIG_IsOK(ecode5)) {
17950  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
17951  }
17952  arg5 = static_cast< PLINT >(val5);
17953  ecode6 = SWIG_AsVal_double(args(5), &val6);
17954  if (!SWIG_IsOK(ecode6)) {
17955  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
17956  }
17957  arg6 = static_cast< PLFLT >(val6);
17958  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17959  _outv = octave_value();
17960  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17961  if (SWIG_IsTmpObj(res7)) {
17962  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
17963  } else {
17964  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17965  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
17966  }
17967  return _out;
17968  fail:
17969  return octave_value_list();
17970  }
17971  catch(...) {
17972  throw;
17973  }
17974 }
17975 
17976 
17978  PLINT arg1 ;
17979  PLBOOL arg2 ;
17980  int val1 ;
17981  int ecode1 = 0 ;
17982  int val2 ;
17983  int ecode2 = 0 ;
17984  octave_value_list _out;
17985  octave_value_list *_outp=&_out;
17986  octave_value _outv;
17987 
17988  try {
17989  if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
17990  SWIG_fail;
17991  }
17992  ecode1 = SWIG_AsVal_int(args(0), &val1);
17993  if (!SWIG_IsOK(ecode1)) {
17994  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
17995  }
17996  arg1 = static_cast< PLINT >(val1);
17997  ecode2 = SWIG_AsVal_int(args(1), &val2);
17998  if (!SWIG_IsOK(ecode2)) {
17999  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
18000  }
18001  arg2 = static_cast< PLBOOL >(val2);
18002  plcpstrm(arg1,arg2);
18003  _outv = octave_value();
18004  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18005  return _out;
18006  fail:
18007  return octave_value_list();
18008  }
18009  catch(...) {
18010  throw;
18011  }
18012 }
18013 
18014 
18016  octave_value_list _out;
18017  octave_value_list *_outp=&_out;
18018  octave_value _outv;
18019 
18020  try {
18021  if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
18022  SWIG_fail;
18023  }
18024  plend();
18025  _outv = octave_value();
18026  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18027  return _out;
18028  fail:
18029  return octave_value_list();
18030  }
18031  catch(...) {
18032  throw;
18033  }
18034 }
18035 
18036 
18038  octave_value_list _out;
18039  octave_value_list *_outp=&_out;
18040  octave_value _outv;
18041 
18042  try {
18043  if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
18044  SWIG_fail;
18045  }
18046  plend1();
18047  _outv = octave_value();
18048  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18049  return _out;
18050  fail:
18051  return octave_value_list();
18052  }
18053  catch(...) {
18054  throw;
18055  }
18056 }
18057 
18058 
18060  PLFLT arg1 ;
18061  PLFLT arg2 ;
18062  PLFLT arg3 ;
18063  PLFLT arg4 ;
18064  PLINT arg5 ;
18065  PLINT arg6 ;
18066  double val1 ;
18067  int ecode1 = 0 ;
18068  double val2 ;
18069  int ecode2 = 0 ;
18070  double val3 ;
18071  int ecode3 = 0 ;
18072  double val4 ;
18073  int ecode4 = 0 ;
18074  int val5 ;
18075  int ecode5 = 0 ;
18076  int val6 ;
18077  int ecode6 = 0 ;
18078  octave_value_list _out;
18079  octave_value_list *_outp=&_out;
18080  octave_value _outv;
18081 
18082  try {
18083  if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
18084  SWIG_fail;
18085  }
18086  ecode1 = SWIG_AsVal_double(args(0), &val1);
18087  if (!SWIG_IsOK(ecode1)) {
18088  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
18089  }
18090  arg1 = static_cast< PLFLT >(val1);
18091  ecode2 = SWIG_AsVal_double(args(1), &val2);
18092  if (!SWIG_IsOK(ecode2)) {
18093  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
18094  }
18095  arg2 = static_cast< PLFLT >(val2);
18096  ecode3 = SWIG_AsVal_double(args(2), &val3);
18097  if (!SWIG_IsOK(ecode3)) {
18098  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
18099  }
18100  arg3 = static_cast< PLFLT >(val3);
18101  ecode4 = SWIG_AsVal_double(args(3), &val4);
18102  if (!SWIG_IsOK(ecode4)) {
18103  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
18104  }
18105  arg4 = static_cast< PLFLT >(val4);
18106  ecode5 = SWIG_AsVal_int(args(4), &val5);
18107  if (!SWIG_IsOK(ecode5)) {
18108  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
18109  }
18110  arg5 = static_cast< PLINT >(val5);
18111  ecode6 = SWIG_AsVal_int(args(5), &val6);
18112  if (!SWIG_IsOK(ecode6)) {
18113  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
18114  }
18115  arg6 = static_cast< PLINT >(val6);
18116  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18117  _outv = octave_value();
18118  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18119  return _out;
18120  fail:
18121  return octave_value_list();
18122  }
18123  catch(...) {
18124  throw;
18125  }
18126 }
18127 
18128 
18130  PLFLT arg1 ;
18131  PLFLT arg2 ;
18132  PLFLT arg3 ;
18133  PLFLT arg4 ;
18134  PLINT arg5 ;
18135  PLINT arg6 ;
18136  double val1 ;
18137  int ecode1 = 0 ;
18138  double val2 ;
18139  int ecode2 = 0 ;
18140  double val3 ;
18141  int ecode3 = 0 ;
18142  double val4 ;
18143  int ecode4 = 0 ;
18144  int val5 ;
18145  int ecode5 = 0 ;
18146  int val6 ;
18147  int ecode6 = 0 ;
18148  octave_value_list _out;
18149  octave_value_list *_outp=&_out;
18150  octave_value _outv;
18151 
18152  try {
18153  if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
18154  SWIG_fail;
18155  }
18156  ecode1 = SWIG_AsVal_double(args(0), &val1);
18157  if (!SWIG_IsOK(ecode1)) {
18158  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
18159  }
18160  arg1 = static_cast< PLFLT >(val1);
18161  ecode2 = SWIG_AsVal_double(args(1), &val2);
18162  if (!SWIG_IsOK(ecode2)) {
18163  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
18164  }
18165  arg2 = static_cast< PLFLT >(val2);
18166  ecode3 = SWIG_AsVal_double(args(2), &val3);
18167  if (!SWIG_IsOK(ecode3)) {
18168  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
18169  }
18170  arg3 = static_cast< PLFLT >(val3);
18171  ecode4 = SWIG_AsVal_double(args(3), &val4);
18172  if (!SWIG_IsOK(ecode4)) {
18173  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
18174  }
18175  arg4 = static_cast< PLFLT >(val4);
18176  ecode5 = SWIG_AsVal_int(args(4), &val5);
18177  if (!SWIG_IsOK(ecode5)) {
18178  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
18179  }
18180  arg5 = static_cast< PLINT >(val5);
18181  ecode6 = SWIG_AsVal_int(args(5), &val6);
18182  if (!SWIG_IsOK(ecode6)) {
18183  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
18184  }
18185  arg6 = static_cast< PLINT >(val6);
18186  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18187  _outv = octave_value();
18188  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18189  return _out;
18190  fail:
18191  return octave_value_list();
18192  }
18193  catch(...) {
18194  throw;
18195  }
18196 }
18197 
18198 
18200  octave_value_list _out;
18201  octave_value_list *_outp=&_out;
18202  octave_value _outv;
18203 
18204  try {
18205  if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
18206  SWIG_fail;
18207  }
18208  pleop();
18209  _outv = octave_value();
18210  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18211  return _out;
18212  fail:
18213  return octave_value_list();
18214  }
18215  catch(...) {
18216  throw;
18217  }
18218 }
18219 
18220 
18222  PLINT arg1 ;
18223  PLFLT *arg2 = (PLFLT *) 0 ;
18224  PLFLT *arg3 = (PLFLT *) 0 ;
18225  PLFLT *arg4 = (PLFLT *) 0 ;
18226  Matrix temp1 ;
18227  Matrix temp3 ;
18228  Matrix temp4 ;
18229  octave_value_list _out;
18230  octave_value_list *_outp=&_out;
18231  octave_value _outv;
18232 
18233  try {
18234  if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
18235  SWIG_fail;
18236  }
18237  {
18238  if ( _n_dims( args(0) ) > 1 )
18239  {
18240  error( "argument must be a scalar or vector" ); SWIG_fail;
18241  }
18242  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18243  temp1 = args(0).matrix_value();
18244  arg2 = &temp1( 0, 0 );
18245  }
18246  {
18247  if ( _n_dims( args(1) ) > 1 )
18248  {
18249  error( "argument must be a scalar or vector" ); SWIG_fail;
18250  }
18251  if ( _dim( args(1), 0 ) != Alen )
18252  {
18253  error( "argument vectors must be same length" ); SWIG_fail;
18254  }
18255  temp3 = args(1).matrix_value();
18256  arg3 = &temp3( 0, 0 );
18257  }
18258  {
18259  if ( _n_dims( args(2) ) > 1 )
18260  {
18261  error( "argument must be a scalar or vector" ); SWIG_fail;
18262  }
18263  if ( _dim( args(2), 0 ) != Alen )
18264  {
18265  error( "argument vectors must be same length" ); SWIG_fail;
18266  }
18267  temp4 = args(2).matrix_value();
18268  arg4 = &temp4( 0, 0 );
18269  }
18270  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18271  _outv = octave_value();
18272  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18273  {
18274 
18275  }
18276  {
18277 
18278  }
18279  {
18280 
18281  }
18282  return _out;
18283  fail:
18284  {
18285 
18286  }
18287  {
18288 
18289  }
18290  {
18291 
18292  }
18293  return octave_value_list();
18294  }
18295  catch(...) {
18296  {
18297 
18298  }
18299  {
18300 
18301  }
18302  {
18303 
18304  }
18305  throw;
18306  }
18307 }
18308 
18309 
18311  PLINT arg1 ;
18312  PLFLT *arg2 = (PLFLT *) 0 ;
18313  PLFLT *arg3 = (PLFLT *) 0 ;
18314  PLFLT *arg4 = (PLFLT *) 0 ;
18315  Matrix temp1 ;
18316  Matrix temp3 ;
18317  Matrix temp4 ;
18318  octave_value_list _out;
18319  octave_value_list *_outp=&_out;
18320  octave_value _outv;
18321 
18322  try {
18323  if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
18324  SWIG_fail;
18325  }
18326  {
18327  if ( _n_dims( args(0) ) > 1 )
18328  {
18329  error( "argument must be a scalar or vector" ); SWIG_fail;
18330  }
18331  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18332  temp1 = args(0).matrix_value();
18333  arg2 = &temp1( 0, 0 );
18334  }
18335  {
18336  if ( _n_dims( args(1) ) > 1 )
18337  {
18338  error( "argument must be a scalar or vector" ); SWIG_fail;
18339  }
18340  if ( _dim( args(1), 0 ) != Alen )
18341  {
18342  error( "argument vectors must be same length" ); SWIG_fail;
18343  }
18344  temp3 = args(1).matrix_value();
18345  arg3 = &temp3( 0, 0 );
18346  }
18347  {
18348  if ( _n_dims( args(2) ) > 1 )
18349  {
18350  error( "argument must be a scalar or vector" ); SWIG_fail;
18351  }
18352  if ( _dim( args(2), 0 ) != Alen )
18353  {
18354  error( "argument vectors must be same length" ); SWIG_fail;
18355  }
18356  temp4 = args(2).matrix_value();
18357  arg4 = &temp4( 0, 0 );
18358  }
18359  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18360  _outv = octave_value();
18361  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18362  {
18363 
18364  }
18365  {
18366 
18367  }
18368  {
18369 
18370  }
18371  return _out;
18372  fail:
18373  {
18374 
18375  }
18376  {
18377 
18378  }
18379  {
18380 
18381  }
18382  return octave_value_list();
18383  }
18384  catch(...) {
18385  {
18386 
18387  }
18388  {
18389 
18390  }
18391  {
18392 
18393  }
18394  throw;
18395  }
18396 }
18397 
18398 
18400  octave_value_list _out;
18401  octave_value_list *_outp=&_out;
18402  octave_value _outv;
18403 
18404  try {
18405  if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
18406  SWIG_fail;
18407  }
18408  plfamadv();
18409  _outv = octave_value();
18410  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18411  return _out;
18412  fail:
18413  return octave_value_list();
18414  }
18415  catch(...) {
18416  throw;
18417  }
18418 }
18419 
18420 
18422  PLINT arg1 ;
18423  PLFLT *arg2 = (PLFLT *) 0 ;
18424  PLFLT *arg3 = (PLFLT *) 0 ;
18425  Matrix temp1 ;
18426  Matrix temp3 ;
18427  octave_value_list _out;
18428  octave_value_list *_outp=&_out;
18429  octave_value _outv;
18430 
18431  try {
18432  if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
18433  SWIG_fail;
18434  }
18435  {
18436  if ( _n_dims( args(0) ) > 1 )
18437  {
18438  error( "argument must be a scalar or vector" ); SWIG_fail;
18439  }
18440  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18441  temp1 = args(0).matrix_value();
18442  arg2 = &temp1( 0, 0 );
18443  }
18444  {
18445  if ( _n_dims( args(1) ) > 1 )
18446  {
18447  error( "argument must be a scalar or vector" ); SWIG_fail;
18448  }
18449  if ( _dim( args(1), 0 ) != Alen )
18450  {
18451  error( "argument vectors must be same length" ); SWIG_fail;
18452  }
18453  temp3 = args(1).matrix_value();
18454  arg3 = &temp3( 0, 0 );
18455  }
18456  plfill(arg1,(double const *)arg2,(double const *)arg3);
18457  _outv = octave_value();
18458  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18459  {
18460 
18461  }
18462  {
18463 
18464  }
18465  return _out;
18466  fail:
18467  {
18468 
18469  }
18470  {
18471 
18472  }
18473  return octave_value_list();
18474  }
18475  catch(...) {
18476  {
18477 
18478  }
18479  {
18480 
18481  }
18482  throw;
18483  }
18484 }
18485 
18486 
18488  PLINT arg1 ;
18489  PLFLT *arg2 = (PLFLT *) 0 ;
18490  PLFLT *arg3 = (PLFLT *) 0 ;
18491  PLFLT *arg4 = (PLFLT *) 0 ;
18492  Matrix temp1 ;
18493  Matrix temp3 ;
18494  Matrix temp4 ;
18495  octave_value_list _out;
18496  octave_value_list *_outp=&_out;
18497  octave_value _outv;
18498 
18499  try {
18500  if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
18501  SWIG_fail;
18502  }
18503  {
18504  if ( _n_dims( args(0) ) > 1 )
18505  {
18506  error( "argument must be a scalar or vector" ); SWIG_fail;
18507  }
18508  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18509  temp1 = args(0).matrix_value();
18510  arg2 = &temp1( 0, 0 );
18511  }
18512  {
18513  if ( _n_dims( args(1) ) > 1 )
18514  {
18515  error( "argument must be a scalar or vector" ); SWIG_fail;
18516  }
18517  if ( _dim( args(1), 0 ) != Alen )
18518  {
18519  error( "argument vectors must be same length" ); SWIG_fail;
18520  }
18521  temp3 = args(1).matrix_value();
18522  arg3 = &temp3( 0, 0 );
18523  }
18524  {
18525  if ( _n_dims( args(2) ) > 1 )
18526  {
18527  error( "argument must be a scalar or vector" ); SWIG_fail;
18528  }
18529  if ( _dim( args(2), 0 ) != Alen )
18530  {
18531  error( "argument vectors must be same length" ); SWIG_fail;
18532  }
18533  temp4 = args(2).matrix_value();
18534  arg4 = &temp4( 0, 0 );
18535  }
18536  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18537  _outv = octave_value();
18538  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18539  {
18540 
18541  }
18542  {
18543 
18544  }
18545  {
18546 
18547  }
18548  return _out;
18549  fail:
18550  {
18551 
18552  }
18553  {
18554 
18555  }
18556  {
18557 
18558  }
18559  return octave_value_list();
18560  }
18561  catch(...) {
18562  {
18563 
18564  }
18565  {
18566 
18567  }
18568  {
18569 
18570  }
18571  throw;
18572  }
18573 }
18574 
18575 
18577  PLINT arg1 ;
18578  PLFLT *arg2 = (PLFLT *) 0 ;
18579  PLFLT *arg3 = (PLFLT *) 0 ;
18580  PLFLT arg4 ;
18581  Matrix temp1 ;
18582  Matrix temp3 ;
18583  double val4 ;
18584  int ecode4 = 0 ;
18585  octave_value_list _out;
18586  octave_value_list *_outp=&_out;
18587  octave_value _outv;
18588 
18589  try {
18590  if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
18591  SWIG_fail;
18592  }
18593  {
18594  if ( _n_dims( args(0) ) > 1 )
18595  {
18596  error( "argument must be a scalar or vector" ); SWIG_fail;
18597  }
18598  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18599  temp1 = args(0).matrix_value();
18600  arg2 = &temp1( 0, 0 );
18601  }
18602  {
18603  if ( _n_dims( args(1) ) > 1 )
18604  {
18605  error( "argument must be a scalar or vector" ); SWIG_fail;
18606  }
18607  if ( _dim( args(1), 0 ) != Alen )
18608  {
18609  error( "argument vectors must be same length" ); SWIG_fail;
18610  }
18611  temp3 = args(1).matrix_value();
18612  arg3 = &temp3( 0, 0 );
18613  }
18614  ecode4 = SWIG_AsVal_double(args(2), &val4);
18615  if (!SWIG_IsOK(ecode4)) {
18616  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
18617  }
18618  arg4 = static_cast< PLFLT >(val4);
18619  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
18620  _outv = octave_value();
18621  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18622  {
18623 
18624  }
18625  {
18626 
18627  }
18628  return _out;
18629  fail:
18630  {
18631 
18632  }
18633  {
18634 
18635  }
18636  return octave_value_list();
18637  }
18638  catch(...) {
18639  {
18640 
18641  }
18642  {
18643 
18644  }
18645  throw;
18646  }
18647 }
18648 
18649 
18651  octave_value_list _out;
18652  octave_value_list *_outp=&_out;
18653  octave_value _outv;
18654 
18655  try {
18656  if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
18657  SWIG_fail;
18658  }
18659  plflush();
18660  _outv = octave_value();
18661  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18662  return _out;
18663  fail:
18664  return octave_value_list();
18665  }
18666  catch(...) {
18667  throw;
18668  }
18669 }
18670 
18671 
18673  PLINT arg1 ;
18674  int val1 ;
18675  int ecode1 = 0 ;
18676  octave_value_list _out;
18677  octave_value_list *_outp=&_out;
18678  octave_value _outv;
18679 
18680  try {
18681  if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
18682  SWIG_fail;
18683  }
18684  ecode1 = SWIG_AsVal_int(args(0), &val1);
18685  if (!SWIG_IsOK(ecode1)) {
18686  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
18687  }
18688  arg1 = static_cast< PLINT >(val1);
18689  plfont(arg1);
18690  _outv = octave_value();
18691  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18692  return _out;
18693  fail:
18694  return octave_value_list();
18695  }
18696  catch(...) {
18697  throw;
18698  }
18699 }
18700 
18701 
18703  PLINT arg1 ;
18704  int val1 ;
18705  int ecode1 = 0 ;
18706  octave_value_list _out;
18707  octave_value_list *_outp=&_out;
18708  octave_value _outv;
18709 
18710  try {
18711  if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
18712  SWIG_fail;
18713  }
18714  ecode1 = SWIG_AsVal_int(args(0), &val1);
18715  if (!SWIG_IsOK(ecode1)) {
18716  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
18717  }
18718  arg1 = static_cast< PLINT >(val1);
18719  plfontld(arg1);
18720  _outv = octave_value();
18721  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18722  return _out;
18723  fail:
18724  return octave_value_list();
18725  }
18726  catch(...) {
18727  throw;
18728  }
18729 }
18730 
18731 
18733  PLFLT *arg1 = (PLFLT *) 0 ;
18734  PLFLT *arg2 = (PLFLT *) 0 ;
18735  PLFLT temp1 ;
18736  int res1 = SWIG_TMPOBJ ;
18737  PLFLT temp2 ;
18738  int res2 = SWIG_TMPOBJ ;
18739  octave_value_list _out;
18740  octave_value_list *_outp=&_out;
18741  octave_value _outv;
18742 
18743  try {
18744  arg1 = &temp1;
18745  arg2 = &temp2;
18746  if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
18747  SWIG_fail;
18748  }
18749  plgchr(arg1,arg2);
18750  _outv = octave_value();
18751  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18752  if (SWIG_IsTmpObj(res1)) {
18753  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18754  } else {
18755  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18756  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18757  }
18758  if (SWIG_IsTmpObj(res2)) {
18759  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18760  } else {
18761  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18762  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18763  }
18764  return _out;
18765  fail:
18766  return octave_value_list();
18767  }
18768  catch(...) {
18769  throw;
18770  }
18771 }
18772 
18773 
18775  PLINT arg1 ;
18776  PLINT *arg2 = (PLINT *) 0 ;
18777  PLINT *arg3 = (PLINT *) 0 ;
18778  PLINT *arg4 = (PLINT *) 0 ;
18779  int val1 ;
18780  int ecode1 = 0 ;
18781  PLINT temp2 ;
18782  int res2 = SWIG_TMPOBJ ;
18783  PLINT temp3 ;
18784  int res3 = SWIG_TMPOBJ ;
18785  PLINT temp4 ;
18786  int res4 = SWIG_TMPOBJ ;
18787  octave_value_list _out;
18788  octave_value_list *_outp=&_out;
18789  octave_value _outv;
18790 
18791  try {
18792  arg2 = &temp2;
18793  arg3 = &temp3;
18794  arg4 = &temp4;
18795  if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
18796  SWIG_fail;
18797  }
18798  ecode1 = SWIG_AsVal_int(args(0), &val1);
18799  if (!SWIG_IsOK(ecode1)) {
18800  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
18801  }
18802  arg1 = static_cast< PLINT >(val1);
18803  plgcol0(arg1,arg2,arg3,arg4);
18804  _outv = octave_value();
18805  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18806  if (SWIG_IsTmpObj(res2)) {
18807  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18808  } else {
18809  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18810  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18811  }
18812  if (SWIG_IsTmpObj(res3)) {
18813  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18814  } else {
18815  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18816  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18817  }
18818  if (SWIG_IsTmpObj(res4)) {
18819  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18820  } else {
18821  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18822  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18823  }
18824  return _out;
18825  fail:
18826  return octave_value_list();
18827  }
18828  catch(...) {
18829  throw;
18830  }
18831 }
18832 
18833 
18835  PLINT arg1 ;
18836  PLINT *arg2 = (PLINT *) 0 ;
18837  PLINT *arg3 = (PLINT *) 0 ;
18838  PLINT *arg4 = (PLINT *) 0 ;
18839  PLFLT *arg5 = (PLFLT *) 0 ;
18840  int val1 ;
18841  int ecode1 = 0 ;
18842  PLINT temp2 ;
18843  int res2 = SWIG_TMPOBJ ;
18844  PLINT temp3 ;
18845  int res3 = SWIG_TMPOBJ ;
18846  PLINT temp4 ;
18847  int res4 = SWIG_TMPOBJ ;
18848  PLFLT temp5 ;
18849  int res5 = SWIG_TMPOBJ ;
18850  octave_value_list _out;
18851  octave_value_list *_outp=&_out;
18852  octave_value _outv;
18853 
18854  try {
18855  arg2 = &temp2;
18856  arg3 = &temp3;
18857  arg4 = &temp4;
18858  arg5 = &temp5;
18859  if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
18860  SWIG_fail;
18861  }
18862  ecode1 = SWIG_AsVal_int(args(0), &val1);
18863  if (!SWIG_IsOK(ecode1)) {
18864  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
18865  }
18866  arg1 = static_cast< PLINT >(val1);
18867  plgcol0a(arg1,arg2,arg3,arg4,arg5);
18868  _outv = octave_value();
18869  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18870  if (SWIG_IsTmpObj(res2)) {
18871  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18872  } else {
18873  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18874  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18875  }
18876  if (SWIG_IsTmpObj(res3)) {
18877  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18878  } else {
18879  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18880  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18881  }
18882  if (SWIG_IsTmpObj(res4)) {
18883  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18884  } else {
18885  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18886  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18887  }
18888  if (SWIG_IsTmpObj(res5)) {
18889  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
18890  } else {
18891  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18892  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
18893  }
18894  return _out;
18895  fail:
18896  return octave_value_list();
18897  }
18898  catch(...) {
18899  throw;
18900  }
18901 }
18902 
18903 
18905  PLINT *arg1 = (PLINT *) 0 ;
18906  PLINT *arg2 = (PLINT *) 0 ;
18907  PLINT *arg3 = (PLINT *) 0 ;
18908  PLINT temp1 ;
18909  int res1 = SWIG_TMPOBJ ;
18910  PLINT temp2 ;
18911  int res2 = SWIG_TMPOBJ ;
18912  PLINT temp3 ;
18913  int res3 = SWIG_TMPOBJ ;
18914  octave_value_list _out;
18915  octave_value_list *_outp=&_out;
18916  octave_value _outv;
18917 
18918  try {
18919  arg1 = &temp1;
18920  arg2 = &temp2;
18921  arg3 = &temp3;
18922  if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
18923  SWIG_fail;
18924  }
18925  plgcolbg(arg1,arg2,arg3);
18926  _outv = octave_value();
18927  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18928  if (SWIG_IsTmpObj(res1)) {
18929  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18930  } else {
18931  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18932  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18933  }
18934  if (SWIG_IsTmpObj(res2)) {
18935  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18936  } else {
18937  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18938  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18939  }
18940  if (SWIG_IsTmpObj(res3)) {
18941  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18942  } else {
18943  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18944  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18945  }
18946  return _out;
18947  fail:
18948  return octave_value_list();
18949  }
18950  catch(...) {
18951  throw;
18952  }
18953 }
18954 
18955 
18957  PLINT *arg1 = (PLINT *) 0 ;
18958  PLINT *arg2 = (PLINT *) 0 ;
18959  PLINT *arg3 = (PLINT *) 0 ;
18960  PLFLT *arg4 = (PLFLT *) 0 ;
18961  PLINT temp1 ;
18962  int res1 = SWIG_TMPOBJ ;
18963  PLINT temp2 ;
18964  int res2 = SWIG_TMPOBJ ;
18965  PLINT temp3 ;
18966  int res3 = SWIG_TMPOBJ ;
18967  PLFLT temp4 ;
18968  int res4 = SWIG_TMPOBJ ;
18969  octave_value_list _out;
18970  octave_value_list *_outp=&_out;
18971  octave_value _outv;
18972 
18973  try {
18974  arg1 = &temp1;
18975  arg2 = &temp2;
18976  arg3 = &temp3;
18977  arg4 = &temp4;
18978  if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
18979  SWIG_fail;
18980  }
18981  plgcolbga(arg1,arg2,arg3,arg4);
18982  _outv = octave_value();
18983  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18984  if (SWIG_IsTmpObj(res1)) {
18985  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18986  } else {
18987  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18988  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18989  }
18990  if (SWIG_IsTmpObj(res2)) {
18991  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18992  } else {
18993  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18994  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18995  }
18996  if (SWIG_IsTmpObj(res3)) {
18997  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18998  } else {
18999  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19000  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19001  }
19002  if (SWIG_IsTmpObj(res4)) {
19003  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19004  } else {
19005  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19006  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19007  }
19008  return _out;
19009  fail:
19010  return octave_value_list();
19011  }
19012  catch(...) {
19013  throw;
19014  }
19015 }
19016 
19017 
19019  PLINT *arg1 = (PLINT *) 0 ;
19020  PLINT temp1 ;
19021  int res1 = SWIG_TMPOBJ ;
19022  octave_value_list _out;
19023  octave_value_list *_outp=&_out;
19024  octave_value _outv;
19025 
19026  try {
19027  arg1 = &temp1;
19028  if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
19029  SWIG_fail;
19030  }
19031  plgcompression(arg1);
19032  _outv = octave_value();
19033  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19034  if (SWIG_IsTmpObj(res1)) {
19035  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19036  } else {
19037  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19038  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19039  }
19040  return _out;
19041  fail:
19042  return octave_value_list();
19043  }
19044  catch(...) {
19045  throw;
19046  }
19047 }
19048 
19049 
19051  char *arg1 = (char *) 0 ;
19052  char local_string1[80] ;
19053  size_t local_string_length1 ;
19054  charMatrix local_charMatrix1 ;
19055  octave_value_list retval1 ;
19056  octave_value_list _out;
19057  octave_value_list *_outp=&_out;
19058  octave_value _outv;
19059 
19060  try {
19061  {
19062  arg1 = local_string1;
19063  }
19064  if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
19065  SWIG_fail;
19066  }
19067  plgdev(arg1);
19068  _outv = octave_value();
19069  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19070  {
19071  local_string_length1 = strlen( local_string1 );
19072  local_charMatrix1 = charMatrix( 1, local_string_length1 );
19073  local_charMatrix1.insert( local_string1, 0, 0 );
19074  retval1( 0 ) = octave_value( local_charMatrix1 );
19075  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19076  }
19077  return _out;
19078  fail:
19079  return octave_value_list();
19080  }
19081  catch(...) {
19082  throw;
19083  }
19084 }
19085 
19086 
19088  PLFLT *arg1 = (PLFLT *) 0 ;
19089  PLFLT *arg2 = (PLFLT *) 0 ;
19090  PLFLT *arg3 = (PLFLT *) 0 ;
19091  PLFLT *arg4 = (PLFLT *) 0 ;
19092  PLFLT temp1 ;
19093  int res1 = SWIG_TMPOBJ ;
19094  PLFLT temp2 ;
19095  int res2 = SWIG_TMPOBJ ;
19096  PLFLT temp3 ;
19097  int res3 = SWIG_TMPOBJ ;
19098  PLFLT temp4 ;
19099  int res4 = SWIG_TMPOBJ ;
19100  octave_value_list _out;
19101  octave_value_list *_outp=&_out;
19102  octave_value _outv;
19103 
19104  try {
19105  arg1 = &temp1;
19106  arg2 = &temp2;
19107  arg3 = &temp3;
19108  arg4 = &temp4;
19109  if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
19110  SWIG_fail;
19111  }
19112  plgdidev(arg1,arg2,arg3,arg4);
19113  _outv = octave_value();
19114  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19115  if (SWIG_IsTmpObj(res1)) {
19116  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19117  } else {
19118  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19119  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19120  }
19121  if (SWIG_IsTmpObj(res2)) {
19122  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19123  } else {
19124  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19125  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19126  }
19127  if (SWIG_IsTmpObj(res3)) {
19128  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19129  } else {
19130  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19131  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19132  }
19133  if (SWIG_IsTmpObj(res4)) {
19134  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19135  } else {
19136  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19137  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19138  }
19139  return _out;
19140  fail:
19141  return octave_value_list();
19142  }
19143  catch(...) {
19144  throw;
19145  }
19146 }
19147 
19148 
19150  PLFLT *arg1 = (PLFLT *) 0 ;
19151  PLFLT temp1 ;
19152  int res1 = SWIG_TMPOBJ ;
19153  octave_value_list _out;
19154  octave_value_list *_outp=&_out;
19155  octave_value _outv;
19156 
19157  try {
19158  arg1 = &temp1;
19159  if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
19160  SWIG_fail;
19161  }
19162  plgdiori(arg1);
19163  _outv = octave_value();
19164  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19165  if (SWIG_IsTmpObj(res1)) {
19166  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19167  } else {
19168  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19169  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19170  }
19171  return _out;
19172  fail:
19173  return octave_value_list();
19174  }
19175  catch(...) {
19176  throw;
19177  }
19178 }
19179 
19180 
19182  PLFLT *arg1 = (PLFLT *) 0 ;
19183  PLFLT *arg2 = (PLFLT *) 0 ;
19184  PLFLT *arg3 = (PLFLT *) 0 ;
19185  PLFLT *arg4 = (PLFLT *) 0 ;
19186  PLFLT temp1 ;
19187  int res1 = SWIG_TMPOBJ ;
19188  PLFLT temp2 ;
19189  int res2 = SWIG_TMPOBJ ;
19190  PLFLT temp3 ;
19191  int res3 = SWIG_TMPOBJ ;
19192  PLFLT temp4 ;
19193  int res4 = SWIG_TMPOBJ ;
19194  octave_value_list _out;
19195  octave_value_list *_outp=&_out;
19196  octave_value _outv;
19197 
19198  try {
19199  arg1 = &temp1;
19200  arg2 = &temp2;
19201  arg3 = &temp3;
19202  arg4 = &temp4;
19203  if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
19204  SWIG_fail;
19205  }
19206  plgdiplt(arg1,arg2,arg3,arg4);
19207  _outv = octave_value();
19208  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19209  if (SWIG_IsTmpObj(res1)) {
19210  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19211  } else {
19212  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19213  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19214  }
19215  if (SWIG_IsTmpObj(res2)) {
19216  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19217  } else {
19218  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19219  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19220  }
19221  if (SWIG_IsTmpObj(res3)) {
19222  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19223  } else {
19224  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19225  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19226  }
19227  if (SWIG_IsTmpObj(res4)) {
19228  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19229  } else {
19230  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19231  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19232  }
19233  return _out;
19234  fail:
19235  return octave_value_list();
19236  }
19237  catch(...) {
19238  throw;
19239  }
19240 }
19241 
19242 
19244  PLINT *arg1 = (PLINT *) 0 ;
19245  PLINT *arg2 = (PLINT *) 0 ;
19246  PLINT *arg3 = (PLINT *) 0 ;
19247  PLINT temp1 ;
19248  int res1 = SWIG_TMPOBJ ;
19249  PLINT temp2 ;
19250  int res2 = SWIG_TMPOBJ ;
19251  PLINT temp3 ;
19252  int res3 = SWIG_TMPOBJ ;
19253  octave_value_list _out;
19254  octave_value_list *_outp=&_out;
19255  octave_value _outv;
19256 
19257  try {
19258  arg1 = &temp1;
19259  arg2 = &temp2;
19260  arg3 = &temp3;
19261  if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
19262  SWIG_fail;
19263  }
19264  plgfam(arg1,arg2,arg3);
19265  _outv = octave_value();
19266  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19267  if (SWIG_IsTmpObj(res1)) {
19268  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19269  } else {
19270  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19271  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19272  }
19273  if (SWIG_IsTmpObj(res2)) {
19274  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19275  } else {
19276  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19277  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19278  }
19279  if (SWIG_IsTmpObj(res3)) {
19280  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19281  } else {
19282  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19283  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19284  }
19285  return _out;
19286  fail:
19287  return octave_value_list();
19288  }
19289  catch(...) {
19290  throw;
19291  }
19292 }
19293 
19294 
19296  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
19297  PLUNICODE temp1 ;
19298  int res1 = SWIG_TMPOBJ ;
19299  octave_value_list _out;
19300  octave_value_list *_outp=&_out;
19301  octave_value _outv;
19302 
19303  try {
19304  arg1 = &temp1;
19305  if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
19306  SWIG_fail;
19307  }
19308  plgfci(arg1);
19309  _outv = octave_value();
19310  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19311  if (SWIG_IsTmpObj(res1)) {
19312  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
19313  } else {
19314  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19315  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
19316  }
19317  return _out;
19318  fail:
19319  return octave_value_list();
19320  }
19321  catch(...) {
19322  throw;
19323  }
19324 }
19325 
19326 
19328  char *arg1 = (char *) 0 ;
19329  char local_string1[80] ;
19330  size_t local_string_length1 ;
19331  charMatrix local_charMatrix1 ;
19332  octave_value_list retval1 ;
19333  octave_value_list _out;
19334  octave_value_list *_outp=&_out;
19335  octave_value _outv;
19336 
19337  try {
19338  {
19339  arg1 = local_string1;
19340  }
19341  if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
19342  SWIG_fail;
19343  }
19344  plgfnam(arg1);
19345  _outv = octave_value();
19346  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19347  {
19348  local_string_length1 = strlen( local_string1 );
19349  local_charMatrix1 = charMatrix( 1, local_string_length1 );
19350  local_charMatrix1.insert( local_string1, 0, 0 );
19351  retval1( 0 ) = octave_value( local_charMatrix1 );
19352  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19353  }
19354  return _out;
19355  fail:
19356  return octave_value_list();
19357  }
19358  catch(...) {
19359  throw;
19360  }
19361 }
19362 
19363 
19365  PLINT *arg1 = (PLINT *) 0 ;
19366  PLINT *arg2 = (PLINT *) 0 ;
19367  PLINT *arg3 = (PLINT *) 0 ;
19368  PLINT temp1 ;
19369  int res1 = SWIG_TMPOBJ ;
19370  PLINT temp2 ;
19371  int res2 = SWIG_TMPOBJ ;
19372  PLINT temp3 ;
19373  int res3 = SWIG_TMPOBJ ;
19374  octave_value_list _out;
19375  octave_value_list *_outp=&_out;
19376  octave_value _outv;
19377 
19378  try {
19379  arg1 = &temp1;
19380  arg2 = &temp2;
19381  arg3 = &temp3;
19382  if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
19383  SWIG_fail;
19384  }
19385  plgfont(arg1,arg2,arg3);
19386  _outv = octave_value();
19387  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19388  if (SWIG_IsTmpObj(res1)) {
19389  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19390  } else {
19391  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19392  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19393  }
19394  if (SWIG_IsTmpObj(res2)) {
19395  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19396  } else {
19397  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19398  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19399  }
19400  if (SWIG_IsTmpObj(res3)) {
19401  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19402  } else {
19403  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19404  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19405  }
19406  return _out;
19407  fail:
19408  return octave_value_list();
19409  }
19410  catch(...) {
19411  throw;
19412  }
19413 }
19414 
19415 
19417  PLINT *arg1 = (PLINT *) 0 ;
19418  PLINT temp1 ;
19419  int res1 = SWIG_TMPOBJ ;
19420  octave_value_list _out;
19421  octave_value_list *_outp=&_out;
19422  octave_value _outv;
19423 
19424  try {
19425  arg1 = &temp1;
19426  if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
19427  SWIG_fail;
19428  }
19429  plglevel(arg1);
19430  _outv = octave_value();
19431  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19432  if (SWIG_IsTmpObj(res1)) {
19433  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19434  } else {
19435  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19436  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19437  }
19438  return _out;
19439  fail:
19440  return octave_value_list();
19441  }
19442  catch(...) {
19443  throw;
19444  }
19445 }
19446 
19447 
19449  PLFLT *arg1 = (PLFLT *) 0 ;
19450  PLFLT *arg2 = (PLFLT *) 0 ;
19451  PLINT *arg3 = (PLINT *) 0 ;
19452  PLINT *arg4 = (PLINT *) 0 ;
19453  PLINT *arg5 = (PLINT *) 0 ;
19454  PLINT *arg6 = (PLINT *) 0 ;
19455  PLFLT temp1 ;
19456  int res1 = SWIG_TMPOBJ ;
19457  PLFLT temp2 ;
19458  int res2 = SWIG_TMPOBJ ;
19459  PLINT temp3 ;
19460  int res3 = SWIG_TMPOBJ ;
19461  PLINT temp4 ;
19462  int res4 = SWIG_TMPOBJ ;
19463  PLINT temp5 ;
19464  int res5 = SWIG_TMPOBJ ;
19465  PLINT temp6 ;
19466  int res6 = SWIG_TMPOBJ ;
19467  octave_value_list _out;
19468  octave_value_list *_outp=&_out;
19469  octave_value _outv;
19470 
19471  try {
19472  arg1 = &temp1;
19473  arg2 = &temp2;
19474  arg3 = &temp3;
19475  arg4 = &temp4;
19476  arg5 = &temp5;
19477  arg6 = &temp6;
19478  if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
19479  SWIG_fail;
19480  }
19481  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19482  _outv = octave_value();
19483  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19484  if (SWIG_IsTmpObj(res1)) {
19485  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19486  } else {
19487  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19488  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19489  }
19490  if (SWIG_IsTmpObj(res2)) {
19491  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19492  } else {
19493  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19494  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19495  }
19496  if (SWIG_IsTmpObj(res3)) {
19497  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19498  } else {
19499  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19500  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19501  }
19502  if (SWIG_IsTmpObj(res4)) {
19503  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19504  } else {
19505  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19506  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19507  }
19508  if (SWIG_IsTmpObj(res5)) {
19509  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
19510  } else {
19511  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19512  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
19513  }
19514  if (SWIG_IsTmpObj(res6)) {
19515  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
19516  } else {
19517  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19518  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
19519  }
19520  return _out;
19521  fail:
19522  return octave_value_list();
19523  }
19524  catch(...) {
19525  throw;
19526  }
19527 }
19528 
19529 
19531  octave_value_list _out;
19532  octave_value_list *_outp=&_out;
19533  octave_value _outv;
19534 
19535  try {
19536  if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
19537  SWIG_fail;
19538  }
19539  plgra();
19540  _outv = octave_value();
19541  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19542  return _out;
19543  fail:
19544  return octave_value_list();
19545  }
19546  catch(...) {
19547  throw;
19548  }
19549 }
19550 
19551 
19553  PLFLT *arg1 = (PLFLT *) 0 ;
19554  PLFLT *arg2 = (PLFLT *) 0 ;
19555  PLFLT *arg3 = (PLFLT *) 0 ;
19556  PLFLT *arg4 = (PLFLT *) 0 ;
19557  PLFLT temp1 ;
19558  int res1 = SWIG_TMPOBJ ;
19559  PLFLT temp2 ;
19560  int res2 = SWIG_TMPOBJ ;
19561  PLFLT temp3 ;
19562  int res3 = SWIG_TMPOBJ ;
19563  PLFLT temp4 ;
19564  int res4 = SWIG_TMPOBJ ;
19565  octave_value_list _out;
19566  octave_value_list *_outp=&_out;
19567  octave_value _outv;
19568 
19569  try {
19570  arg1 = &temp1;
19571  arg2 = &temp2;
19572  arg3 = &temp3;
19573  arg4 = &temp4;
19574  if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
19575  SWIG_fail;
19576  }
19577  plgspa(arg1,arg2,arg3,arg4);
19578  _outv = octave_value();
19579  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19580  if (SWIG_IsTmpObj(res1)) {
19581  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19582  } else {
19583  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19584  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19585  }
19586  if (SWIG_IsTmpObj(res2)) {
19587  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19588  } else {
19589  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19590  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19591  }
19592  if (SWIG_IsTmpObj(res3)) {
19593  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19594  } else {
19595  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19596  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19597  }
19598  if (SWIG_IsTmpObj(res4)) {
19599  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19600  } else {
19601  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19602  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19603  }
19604  return _out;
19605  fail:
19606  return octave_value_list();
19607  }
19608  catch(...) {
19609  throw;
19610  }
19611 }
19612 
19613 
19615  PLINT *arg1 = (PLINT *) 0 ;
19616  PLINT temp1 ;
19617  int res1 = SWIG_TMPOBJ ;
19618  octave_value_list _out;
19619  octave_value_list *_outp=&_out;
19620  octave_value _outv;
19621 
19622  try {
19623  arg1 = &temp1;
19624  if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
19625  SWIG_fail;
19626  }
19627  plgstrm(arg1);
19628  _outv = octave_value();
19629  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19630  if (SWIG_IsTmpObj(res1)) {
19631  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19632  } else {
19633  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19634  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19635  }
19636  return _out;
19637  fail:
19638  return octave_value_list();
19639  }
19640  catch(...) {
19641  throw;
19642  }
19643 }
19644 
19645 
19647  char *arg1 = (char *) 0 ;
19648  char local_string1[80] ;
19649  size_t local_string_length1 ;
19650  charMatrix local_charMatrix1 ;
19651  octave_value_list retval1 ;
19652  octave_value_list _out;
19653  octave_value_list *_outp=&_out;
19654  octave_value _outv;
19655 
19656  try {
19657  {
19658  arg1 = local_string1;
19659  }
19660  if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
19661  SWIG_fail;
19662  }
19663  plgver(arg1);
19664  _outv = octave_value();
19665  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19666  {
19667  local_string_length1 = strlen( local_string1 );
19668  local_charMatrix1 = charMatrix( 1, local_string_length1 );
19669  local_charMatrix1.insert( local_string1, 0, 0 );
19670  retval1( 0 ) = octave_value( local_charMatrix1 );
19671  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19672  }
19673  return _out;
19674  fail:
19675  return octave_value_list();
19676  }
19677  catch(...) {
19678  throw;
19679  }
19680 }
19681 
19682 
19684  PLFLT *arg1 = (PLFLT *) 0 ;
19685  PLFLT *arg2 = (PLFLT *) 0 ;
19686  PLFLT *arg3 = (PLFLT *) 0 ;
19687  PLFLT *arg4 = (PLFLT *) 0 ;
19688  PLFLT temp1 ;
19689  int res1 = SWIG_TMPOBJ ;
19690  PLFLT temp2 ;
19691  int res2 = SWIG_TMPOBJ ;
19692  PLFLT temp3 ;
19693  int res3 = SWIG_TMPOBJ ;
19694  PLFLT temp4 ;
19695  int res4 = SWIG_TMPOBJ ;
19696  octave_value_list _out;
19697  octave_value_list *_outp=&_out;
19698  octave_value _outv;
19699 
19700  try {
19701  arg1 = &temp1;
19702  arg2 = &temp2;
19703  arg3 = &temp3;
19704  arg4 = &temp4;
19705  if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
19706  SWIG_fail;
19707  }
19708  plgvpd(arg1,arg2,arg3,arg4);
19709  _outv = octave_value();
19710  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19711  if (SWIG_IsTmpObj(res1)) {
19712  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19713  } else {
19714  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19715  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19716  }
19717  if (SWIG_IsTmpObj(res2)) {
19718  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19719  } else {
19720  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19721  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19722  }
19723  if (SWIG_IsTmpObj(res3)) {
19724  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19725  } else {
19726  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19727  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19728  }
19729  if (SWIG_IsTmpObj(res4)) {
19730  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19731  } else {
19732  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19733  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19734  }
19735  return _out;
19736  fail:
19737  return octave_value_list();
19738  }
19739  catch(...) {
19740  throw;
19741  }
19742 }
19743 
19744 
19746  PLFLT *arg1 = (PLFLT *) 0 ;
19747  PLFLT *arg2 = (PLFLT *) 0 ;
19748  PLFLT *arg3 = (PLFLT *) 0 ;
19749  PLFLT *arg4 = (PLFLT *) 0 ;
19750  PLFLT temp1 ;
19751  int res1 = SWIG_TMPOBJ ;
19752  PLFLT temp2 ;
19753  int res2 = SWIG_TMPOBJ ;
19754  PLFLT temp3 ;
19755  int res3 = SWIG_TMPOBJ ;
19756  PLFLT temp4 ;
19757  int res4 = SWIG_TMPOBJ ;
19758  octave_value_list _out;
19759  octave_value_list *_outp=&_out;
19760  octave_value _outv;
19761 
19762  try {
19763  arg1 = &temp1;
19764  arg2 = &temp2;
19765  arg3 = &temp3;
19766  arg4 = &temp4;
19767  if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
19768  SWIG_fail;
19769  }
19770  plgvpw(arg1,arg2,arg3,arg4);
19771  _outv = octave_value();
19772  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19773  if (SWIG_IsTmpObj(res1)) {
19774  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19775  } else {
19776  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19777  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19778  }
19779  if (SWIG_IsTmpObj(res2)) {
19780  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19781  } else {
19782  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19783  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19784  }
19785  if (SWIG_IsTmpObj(res3)) {
19786  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19787  } else {
19788  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19789  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19790  }
19791  if (SWIG_IsTmpObj(res4)) {
19792  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19793  } else {
19794  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19795  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19796  }
19797  return _out;
19798  fail:
19799  return octave_value_list();
19800  }
19801  catch(...) {
19802  throw;
19803  }
19804 }
19805 
19806 
19808  PLINT *arg1 = (PLINT *) 0 ;
19809  PLINT *arg2 = (PLINT *) 0 ;
19810  PLINT temp1 ;
19811  int res1 = SWIG_TMPOBJ ;
19812  PLINT temp2 ;
19813  int res2 = SWIG_TMPOBJ ;
19814  octave_value_list _out;
19815  octave_value_list *_outp=&_out;
19816  octave_value _outv;
19817 
19818  try {
19819  arg1 = &temp1;
19820  arg2 = &temp2;
19821  if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
19822  SWIG_fail;
19823  }
19824  plgxax(arg1,arg2);
19825  _outv = octave_value();
19826  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19827  if (SWIG_IsTmpObj(res1)) {
19828  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19829  } else {
19830  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19831  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19832  }
19833  if (SWIG_IsTmpObj(res2)) {
19834  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19835  } else {
19836  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19837  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19838  }
19839  return _out;
19840  fail:
19841  return octave_value_list();
19842  }
19843  catch(...) {
19844  throw;
19845  }
19846 }
19847 
19848 
19850  PLINT *arg1 = (PLINT *) 0 ;
19851  PLINT *arg2 = (PLINT *) 0 ;
19852  PLINT temp1 ;
19853  int res1 = SWIG_TMPOBJ ;
19854  PLINT temp2 ;
19855  int res2 = SWIG_TMPOBJ ;
19856  octave_value_list _out;
19857  octave_value_list *_outp=&_out;
19858  octave_value _outv;
19859 
19860  try {
19861  arg1 = &temp1;
19862  arg2 = &temp2;
19863  if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
19864  SWIG_fail;
19865  }
19866  plgyax(arg1,arg2);
19867  _outv = octave_value();
19868  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19869  if (SWIG_IsTmpObj(res1)) {
19870  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19871  } else {
19872  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19873  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19874  }
19875  if (SWIG_IsTmpObj(res2)) {
19876  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19877  } else {
19878  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19879  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19880  }
19881  return _out;
19882  fail:
19883  return octave_value_list();
19884  }
19885  catch(...) {
19886  throw;
19887  }
19888 }
19889 
19890 
19892  PLINT *arg1 = (PLINT *) 0 ;
19893  PLINT *arg2 = (PLINT *) 0 ;
19894  PLINT temp1 ;
19895  int res1 = SWIG_TMPOBJ ;
19896  PLINT temp2 ;
19897  int res2 = SWIG_TMPOBJ ;
19898  octave_value_list _out;
19899  octave_value_list *_outp=&_out;
19900  octave_value _outv;
19901 
19902  try {
19903  arg1 = &temp1;
19904  arg2 = &temp2;
19905  if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
19906  SWIG_fail;
19907  }
19908  plgzax(arg1,arg2);
19909  _outv = octave_value();
19910  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19911  if (SWIG_IsTmpObj(res1)) {
19912  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19913  } else {
19914  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19915  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19916  }
19917  if (SWIG_IsTmpObj(res2)) {
19918  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19919  } else {
19920  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19921  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19922  }
19923  return _out;
19924  fail:
19925  return octave_value_list();
19926  }
19927  catch(...) {
19928  throw;
19929  }
19930 }
19931 
19932 
19934  PLINT arg1 ;
19935  PLFLT *arg2 = (PLFLT *) 0 ;
19936  PLFLT arg3 ;
19937  PLFLT arg4 ;
19938  PLINT arg5 ;
19939  PLINT arg6 ;
19940  Matrix temp1 ;
19941  double val3 ;
19942  int ecode3 = 0 ;
19943  double val4 ;
19944  int ecode4 = 0 ;
19945  int val5 ;
19946  int ecode5 = 0 ;
19947  int val6 ;
19948  int ecode6 = 0 ;
19949  octave_value_list _out;
19950  octave_value_list *_outp=&_out;
19951  octave_value _outv;
19952 
19953  try {
19954  if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
19955  SWIG_fail;
19956  }
19957  {
19958  if ( _n_dims( args(0) ) > 1 )
19959  {
19960  error( "argument must be a scalar or vector" ); SWIG_fail;
19961  }
19962  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19963  temp1 = args(0).matrix_value();
19964  arg2 = &temp1( 0, 0 );
19965  }
19966  ecode3 = SWIG_AsVal_double(args(1), &val3);
19967  if (!SWIG_IsOK(ecode3)) {
19968  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
19969  }
19970  arg3 = static_cast< PLFLT >(val3);
19971  ecode4 = SWIG_AsVal_double(args(2), &val4);
19972  if (!SWIG_IsOK(ecode4)) {
19973  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
19974  }
19975  arg4 = static_cast< PLFLT >(val4);
19976  ecode5 = SWIG_AsVal_int(args(3), &val5);
19977  if (!SWIG_IsOK(ecode5)) {
19978  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
19979  }
19980  arg5 = static_cast< PLINT >(val5);
19981  ecode6 = SWIG_AsVal_int(args(4), &val6);
19982  if (!SWIG_IsOK(ecode6)) {
19983  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
19984  }
19985  arg6 = static_cast< PLINT >(val6);
19986  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
19987  _outv = octave_value();
19988  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19989  {
19990 
19991  }
19992  return _out;
19993  fail:
19994  {
19995 
19996  }
19997  return octave_value_list();
19998  }
19999  catch(...) {
20000  {
20001 
20002  }
20003  throw;
20004  }
20005 }
20006 
20007 
20009  PLFLT arg1 ;
20010  PLFLT arg2 ;
20011  PLFLT arg3 ;
20012  PLFLT *arg4 = (PLFLT *) 0 ;
20013  PLFLT *arg5 = (PLFLT *) 0 ;
20014  PLFLT *arg6 = (PLFLT *) 0 ;
20015  double val1 ;
20016  int ecode1 = 0 ;
20017  double val2 ;
20018  int ecode2 = 0 ;
20019  double val3 ;
20020  int ecode3 = 0 ;
20021  PLFLT temp4 ;
20022  int res4 = SWIG_TMPOBJ ;
20023  PLFLT temp5 ;
20024  int res5 = SWIG_TMPOBJ ;
20025  PLFLT temp6 ;
20026  int res6 = SWIG_TMPOBJ ;
20027  octave_value_list _out;
20028  octave_value_list *_outp=&_out;
20029  octave_value _outv;
20030 
20031  try {
20032  arg4 = &temp4;
20033  arg5 = &temp5;
20034  arg6 = &temp6;
20035  if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
20036  SWIG_fail;
20037  }
20038  ecode1 = SWIG_AsVal_double(args(0), &val1);
20039  if (!SWIG_IsOK(ecode1)) {
20040  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
20041  }
20042  arg1 = static_cast< PLFLT >(val1);
20043  ecode2 = SWIG_AsVal_double(args(1), &val2);
20044  if (!SWIG_IsOK(ecode2)) {
20045  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
20046  }
20047  arg2 = static_cast< PLFLT >(val2);
20048  ecode3 = SWIG_AsVal_double(args(2), &val3);
20049  if (!SWIG_IsOK(ecode3)) {
20050  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
20051  }
20052  arg3 = static_cast< PLFLT >(val3);
20053  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20054  _outv = octave_value();
20055  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20056  if (SWIG_IsTmpObj(res4)) {
20057  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20058  } else {
20059  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20060  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20061  }
20062  if (SWIG_IsTmpObj(res5)) {
20063  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
20064  } else {
20065  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20066  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
20067  }
20068  if (SWIG_IsTmpObj(res6)) {
20069  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
20070  } else {
20071  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20072  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
20073  }
20074  return _out;
20075  fail:
20076  return octave_value_list();
20077  }
20078  catch(...) {
20079  throw;
20080  }
20081 }
20082 
20083 
20085  octave_value_list _out;
20086  octave_value_list *_outp=&_out;
20087  octave_value _outv;
20088 
20089  try {
20090  if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
20091  SWIG_fail;
20092  }
20093  plinit();
20094  _outv = octave_value();
20095  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20096  return _out;
20097  fail:
20098  return octave_value_list();
20099  }
20100  catch(...) {
20101  throw;
20102  }
20103 }
20104 
20105 
20107  PLFLT arg1 ;
20108  PLFLT arg2 ;
20109  PLFLT arg3 ;
20110  PLFLT arg4 ;
20111  double val1 ;
20112  int ecode1 = 0 ;
20113  double val2 ;
20114  int ecode2 = 0 ;
20115  double val3 ;
20116  int ecode3 = 0 ;
20117  double val4 ;
20118  int ecode4 = 0 ;
20119  octave_value_list _out;
20120  octave_value_list *_outp=&_out;
20121  octave_value _outv;
20122 
20123  try {
20124  if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
20125  SWIG_fail;
20126  }
20127  ecode1 = SWIG_AsVal_double(args(0), &val1);
20128  if (!SWIG_IsOK(ecode1)) {
20129  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
20130  }
20131  arg1 = static_cast< PLFLT >(val1);
20132  ecode2 = SWIG_AsVal_double(args(1), &val2);
20133  if (!SWIG_IsOK(ecode2)) {
20134  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
20135  }
20136  arg2 = static_cast< PLFLT >(val2);
20137  ecode3 = SWIG_AsVal_double(args(2), &val3);
20138  if (!SWIG_IsOK(ecode3)) {
20139  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
20140  }
20141  arg3 = static_cast< PLFLT >(val3);
20142  ecode4 = SWIG_AsVal_double(args(3), &val4);
20143  if (!SWIG_IsOK(ecode4)) {
20144  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
20145  }
20146  arg4 = static_cast< PLFLT >(val4);
20147  pljoin(arg1,arg2,arg3,arg4);
20148  _outv = octave_value();
20149  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20150  return _out;
20151  fail:
20152  return octave_value_list();
20153  }
20154  catch(...) {
20155  throw;
20156  }
20157 }
20158 
20159 
20161  char *arg1 = (char *) 0 ;
20162  char *arg2 = (char *) 0 ;
20163  char *arg3 = (char *) 0 ;
20164  int res1 ;
20165  char *buf1 = 0 ;
20166  int alloc1 = 0 ;
20167  int res2 ;
20168  char *buf2 = 0 ;
20169  int alloc2 = 0 ;
20170  int res3 ;
20171  char *buf3 = 0 ;
20172  int alloc3 = 0 ;
20173  octave_value_list _out;
20174  octave_value_list *_outp=&_out;
20175  octave_value _outv;
20176 
20177  try {
20178  if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
20179  SWIG_fail;
20180  }
20181  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20182  if (!SWIG_IsOK(res1)) {
20183  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
20184  }
20185  arg1 = reinterpret_cast< char * >(buf1);
20186  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20187  if (!SWIG_IsOK(res2)) {
20188  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
20189  }
20190  arg2 = reinterpret_cast< char * >(buf2);
20191  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
20192  if (!SWIG_IsOK(res3)) {
20193  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
20194  }
20195  arg3 = reinterpret_cast< char * >(buf3);
20196  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
20197  _outv = octave_value();
20198  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20199  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20200  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20201  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20202  return _out;
20203  fail:
20204  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20205  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20206  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20207  return octave_value_list();
20208  }
20209  catch(...) {
20210  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20211  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20212  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20213  throw;
20214  }
20215 }
20216 
20217 
20219  PLFLT *arg1 = (PLFLT *) 0 ;
20220  PLFLT *arg2 = (PLFLT *) 0 ;
20221  PLINT arg3 ;
20222  PLINT arg4 ;
20223  PLFLT arg5 ;
20224  PLFLT arg6 ;
20225  PLFLT arg7 ;
20226  PLINT arg8 ;
20227  PLINT arg9 ;
20228  PLINT arg10 ;
20229  PLINT arg11 ;
20230  PLINT arg12 ;
20231  PLINT arg13 ;
20232  PLINT *arg14 = (PLINT *) 0 ;
20233  PLFLT arg15 ;
20234  PLFLT arg16 ;
20235  PLFLT arg17 ;
20236  PLFLT arg18 ;
20237  PLINT *arg19 = (PLINT *) 0 ;
20238  char **arg20 = (char **) 0 ;
20239  PLINT *arg21 = (PLINT *) 0 ;
20240  PLINT *arg22 = (PLINT *) 0 ;
20241  PLFLT *arg23 = (PLFLT *) 0 ;
20242  PLFLT *arg24 = (PLFLT *) 0 ;
20243  PLINT *arg25 = (PLINT *) 0 ;
20244  PLINT *arg26 = (PLINT *) 0 ;
20245  PLFLT *arg27 = (PLFLT *) 0 ;
20246  PLINT *arg28 = (PLINT *) 0 ;
20247  PLFLT *arg29 = (PLFLT *) 0 ;
20248  PLINT *arg30 = (PLINT *) 0 ;
20249  char **arg31 = (char **) 0 ;
20250  PLFLT temp1 ;
20251  int res1 = SWIG_TMPOBJ ;
20252  PLFLT temp2 ;
20253  int res2 = SWIG_TMPOBJ ;
20254  int val3 ;
20255  int ecode3 = 0 ;
20256  int val4 ;
20257  int ecode4 = 0 ;
20258  double val5 ;
20259  int ecode5 = 0 ;
20260  double val6 ;
20261  int ecode6 = 0 ;
20262  double val7 ;
20263  int ecode7 = 0 ;
20264  int val8 ;
20265  int ecode8 = 0 ;
20266  int val9 ;
20267  int ecode9 = 0 ;
20268  int val10 ;
20269  int ecode10 = 0 ;
20270  int val11 ;
20271  int ecode11 = 0 ;
20272  int val12 ;
20273  int ecode12 = 0 ;
20274  Matrix temp13 ;
20275  double val15 ;
20276  int ecode15 = 0 ;
20277  double val16 ;
20278  int ecode16 = 0 ;
20279  double val17 ;
20280  int ecode17 = 0 ;
20281  double val18 ;
20282  int ecode18 = 0 ;
20283  Matrix temp19 ;
20284  Matrix temp21 ;
20285  Matrix temp22 ;
20286  Matrix temp23 ;
20287  Matrix temp24 ;
20288  Matrix temp25 ;
20289  Matrix temp26 ;
20290  Matrix temp27 ;
20291  Matrix temp28 ;
20292  Matrix temp29 ;
20293  Matrix temp30 ;
20294  octave_value_list _out;
20295  octave_value_list *_outp=&_out;
20296  octave_value _outv;
20297 
20298  try {
20299  arg1 = &temp1;
20300  arg2 = &temp2;
20301  if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
20302  SWIG_fail;
20303  }
20304  ecode3 = SWIG_AsVal_int(args(0), &val3);
20305  if (!SWIG_IsOK(ecode3)) {
20306  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
20307  }
20308  arg3 = static_cast< PLINT >(val3);
20309  ecode4 = SWIG_AsVal_int(args(1), &val4);
20310  if (!SWIG_IsOK(ecode4)) {
20311  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
20312  }
20313  arg4 = static_cast< PLINT >(val4);
20314  ecode5 = SWIG_AsVal_double(args(2), &val5);
20315  if (!SWIG_IsOK(ecode5)) {
20316  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
20317  }
20318  arg5 = static_cast< PLFLT >(val5);
20319  ecode6 = SWIG_AsVal_double(args(3), &val6);
20320  if (!SWIG_IsOK(ecode6)) {
20321  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
20322  }
20323  arg6 = static_cast< PLFLT >(val6);
20324  ecode7 = SWIG_AsVal_double(args(4), &val7);
20325  if (!SWIG_IsOK(ecode7)) {
20326  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
20327  }
20328  arg7 = static_cast< PLFLT >(val7);
20329  ecode8 = SWIG_AsVal_int(args(5), &val8);
20330  if (!SWIG_IsOK(ecode8)) {
20331  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
20332  }
20333  arg8 = static_cast< PLINT >(val8);
20334  ecode9 = SWIG_AsVal_int(args(6), &val9);
20335  if (!SWIG_IsOK(ecode9)) {
20336  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
20337  }
20338  arg9 = static_cast< PLINT >(val9);
20339  ecode10 = SWIG_AsVal_int(args(7), &val10);
20340  if (!SWIG_IsOK(ecode10)) {
20341  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
20342  }
20343  arg10 = static_cast< PLINT >(val10);
20344  ecode11 = SWIG_AsVal_int(args(8), &val11);
20345  if (!SWIG_IsOK(ecode11)) {
20346  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
20347  }
20348  arg11 = static_cast< PLINT >(val11);
20349  ecode12 = SWIG_AsVal_int(args(9), &val12);
20350  if (!SWIG_IsOK(ecode12)) {
20351  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
20352  }
20353  arg12 = static_cast< PLINT >(val12);
20354  {
20355  if ( _n_dims( args(10) ) > 1 )
20356  {
20357  error( "argument must be a scalar or vector" ); SWIG_fail;
20358  }
20359  arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
20360  arg14 = new PLINT[Alen];
20361  temp13 = args(10).matrix_value();
20362  _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
20363  }
20364  ecode15 = SWIG_AsVal_double(args(11), &val15);
20365  if (!SWIG_IsOK(ecode15)) {
20366  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
20367  }
20368  arg15 = static_cast< PLFLT >(val15);
20369  ecode16 = SWIG_AsVal_double(args(12), &val16);
20370  if (!SWIG_IsOK(ecode16)) {
20371  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
20372  }
20373  arg16 = static_cast< PLFLT >(val16);
20374  ecode17 = SWIG_AsVal_double(args(13), &val17);
20375  if (!SWIG_IsOK(ecode17)) {
20376  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
20377  }
20378  arg17 = static_cast< PLFLT >(val17);
20379  ecode18 = SWIG_AsVal_double(args(14), &val18);
20380  if (!SWIG_IsOK(ecode18)) {
20381  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
20382  }
20383  arg18 = static_cast< PLFLT >(val18);
20384  {
20385  if ( _n_dims( args(15) ) > 1 )
20386  {
20387  error( "argument must be a scalar or vector" ); SWIG_fail;
20388  }
20389  if ( _dim( args(15), 0 ) != Alen )
20390  {
20391  error( "argument vectors must be same length" ); SWIG_fail;
20392  }
20393  temp19 = args(15).matrix_value();
20394  arg19 = new PLINT[Alen];
20395  _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
20396  }
20397  {
20398  charMatrix temp_matrix;
20399  Cell temp_cell;
20400  char *tmp_cstring;
20401  std::string str;
20402  size_t max_length = 0, non_blank_length;
20403  int i, ifcell;
20404  if ( _n_dims( args(16) ) > 2 )
20405  {
20406  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20407  }
20408 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20409  if ( !args(16).isempty() )
20410 #else
20411  if ( !args(16).is_empty() )
20412 #endif
20413  {
20414  if ( _dim( args(16), 0 ) != Alen )
20415  {
20416  error( "first dimension must be same length as previous vector" ); SWIG_fail;
20417  }
20418  arg20 = new char*[Alen];
20419 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20420  ifcell = args(16).iscell();
20421 #else
20422  ifcell = args(16).is_cell();
20423 #endif
20424  if ( ifcell )
20425  {
20426  temp_cell = args(16).cell_value();
20427  }
20428  else
20429  {
20430  temp_matrix = args(16).char_matrix_value();
20431  // Allow one extra space for null termination.
20432  max_length = _dim( args(16), 1 ) + 1;
20433  }
20434 
20435  for ( i = 0; i < Alen; i++ )
20436  {
20437  // Must copy string to "permanent" location because the string
20438  // location corresponding to tmp_cstring gets
20439  // overwritten for each iteration of loop.
20440  if ( ifcell )
20441  {
20442  if ( temp_cell.elem( i ).is_string() )
20443  {
20444  str = temp_cell.elem( i ).string_value();
20445  // leave room for null termination.
20446  max_length = str.size() + 1;
20447  tmp_cstring = (char *) str.c_str();
20448  }
20449  else
20450  {
20451  // Use null string if user attempts to pass a cell array
20452  // with a non-string element (likely an empty element
20453  // since that should be allowed by the PLplot interface
20454  // if that element is going to be unused).
20455  // leave room for null termination.
20456  max_length = 1;
20457  tmp_cstring = (char *) "";
20458  }
20459  }
20460  else
20461  {
20462  str = temp_matrix.row_as_string( i );
20463  tmp_cstring = (char *) str.c_str();
20464  }
20465  arg20[i] = new char[max_length];
20466  strncpy( arg20[i], tmp_cstring, max_length - 1 );
20467  arg20[i][max_length - 1] = '\0';
20468  // All the trailing blank crapola should not be needed for
20469  // string cell arrays.
20470  if ( !ifcell )
20471  {
20472  // remove trailing-blank padding that is used by the
20473  // charMatrix class to insure all strings in a given
20474  // charMatrix instance have the same length.
20475  // This transformation also removes legitimate trailing
20476  // blanks but there is nothing we can do about that
20477  // for the charMatrix class.
20478 
20479  // Look for trailing nulls first (just in case, although that
20480  // shouldn't happen if charMatrix implemented as documented)
20481  // before looking for trailing blanks.
20482  non_blank_length = max_length - 2;
20483  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
20484  {
20485  non_blank_length--;
20486  }
20487  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
20488  {
20489  non_blank_length--;
20490  }
20491  arg20[i][non_blank_length + 1] = '\0';
20492  }
20493  }
20494  }
20495  else
20496  {
20497  arg20 = NULL;
20498  }
20499  }
20500  {
20501  if ( _n_dims( args(17) ) > 1 )
20502  {
20503  error( "argument must be a scalar or vector" ); SWIG_fail;
20504  }
20505 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20506  if ( !args(17).isempty() )
20507 #else
20508  if ( !args(17).is_empty() )
20509 #endif
20510  {
20511  if ( _dim( args(17), 0 ) != Alen )
20512  {
20513  error( "argument vectors must be same length" ); SWIG_fail;
20514  }
20515  temp21 = args(17).matrix_value();
20516  arg21 = new PLINT[Alen];
20517  _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
20518  }
20519  else
20520  {
20521  arg21 = NULL;
20522  }
20523  }
20524  {
20525  if ( _n_dims( args(18) ) > 1 )
20526  {
20527  error( "argument must be a scalar or vector" ); SWIG_fail;
20528  }
20529 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20530  if ( !args(18).isempty() )
20531 #else
20532  if ( !args(18).is_empty() )
20533 #endif
20534  {
20535  if ( _dim( args(18), 0 ) != Alen )
20536  {
20537  error( "argument vectors must be same length" ); SWIG_fail;
20538  }
20539  temp22 = args(18).matrix_value();
20540  arg22 = new PLINT[Alen];
20541  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
20542  }
20543  else
20544  {
20545  arg22 = NULL;
20546  }
20547  }
20548  {
20549  if ( _n_dims( args(19) ) > 1 )
20550  {
20551  error( "argument must be a scalar or vector" ); SWIG_fail;
20552  }
20553 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20554  if ( !args(19).isempty() )
20555 #else
20556  if ( !args(19).is_empty() )
20557 #endif
20558  {
20559  if ( _dim( args(19), 0 ) != Alen )
20560  {
20561  error( "argument vectors must be same length" ); SWIG_fail;
20562  }
20563  temp23 = args(19).matrix_value();
20564  arg23 = &temp23( 0, 0 );
20565  }
20566  else
20567  {
20568  arg23 = NULL;
20569  }
20570  }
20571  {
20572  if ( _n_dims( args(20) ) > 1 )
20573  {
20574  error( "argument must be a scalar or vector" ); SWIG_fail;
20575  }
20576 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20577  if ( !args(20).isempty() )
20578 #else
20579  if ( !args(20).is_empty() )
20580 #endif
20581  {
20582  if ( _dim( args(20), 0 ) != Alen )
20583  {
20584  error( "argument vectors must be same length" ); SWIG_fail;
20585  }
20586  temp24 = args(20).matrix_value();
20587  arg24 = &temp24( 0, 0 );
20588  }
20589  else
20590  {
20591  arg24 = NULL;
20592  }
20593  }
20594  {
20595  if ( _n_dims( args(21) ) > 1 )
20596  {
20597  error( "argument must be a scalar or vector" ); SWIG_fail;
20598  }
20599 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20600  if ( !args(21).isempty() )
20601 #else
20602  if ( !args(21).is_empty() )
20603 #endif
20604  {
20605  if ( _dim( args(21), 0 ) != Alen )
20606  {
20607  error( "argument vectors must be same length" ); SWIG_fail;
20608  }
20609  temp25 = args(21).matrix_value();
20610  arg25 = new PLINT[Alen];
20611  _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
20612  }
20613  else
20614  {
20615  arg25 = NULL;
20616  }
20617  }
20618  {
20619  if ( _n_dims( args(22) ) > 1 )
20620  {
20621  error( "argument must be a scalar or vector" ); SWIG_fail;
20622  }
20623 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20624  if ( !args(22).isempty() )
20625 #else
20626  if ( !args(22).is_empty() )
20627 #endif
20628  {
20629  if ( _dim( args(22), 0 ) != Alen )
20630  {
20631  error( "argument vectors must be same length" ); SWIG_fail;
20632  }
20633  temp26 = args(22).matrix_value();
20634  arg26 = new PLINT[Alen];
20635  _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
20636  }
20637  else
20638  {
20639  arg26 = NULL;
20640  }
20641  }
20642  {
20643  if ( _n_dims( args(23) ) > 1 )
20644  {
20645  error( "argument must be a scalar or vector" ); SWIG_fail;
20646  }
20647 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20648  if ( !args(23).isempty() )
20649 #else
20650  if ( !args(23).is_empty() )
20651 #endif
20652  {
20653  if ( _dim( args(23), 0 ) != Alen )
20654  {
20655  error( "argument vectors must be same length" ); SWIG_fail;
20656  }
20657  temp27 = args(23).matrix_value();
20658  arg27 = &temp27( 0, 0 );
20659  }
20660  else
20661  {
20662  arg27 = NULL;
20663  }
20664  }
20665  {
20666  if ( _n_dims( args(24) ) > 1 )
20667  {
20668  error( "argument must be a scalar or vector" ); SWIG_fail;
20669  }
20670 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20671  if ( !args(24).isempty() )
20672 #else
20673  if ( !args(24).is_empty() )
20674 #endif
20675  {
20676  if ( _dim( args(24), 0 ) != Alen )
20677  {
20678  error( "argument vectors must be same length" ); SWIG_fail;
20679  }
20680  temp28 = args(24).matrix_value();
20681  arg28 = new PLINT[Alen];
20682  _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
20683  }
20684  else
20685  {
20686  arg28 = NULL;
20687  }
20688  }
20689  {
20690  if ( _n_dims( args(25) ) > 1 )
20691  {
20692  error( "argument must be a scalar or vector" ); SWIG_fail;
20693  }
20694 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20695  if ( !args(25).isempty() )
20696 #else
20697  if ( !args(25).is_empty() )
20698 #endif
20699  {
20700  if ( _dim( args(25), 0 ) != Alen )
20701  {
20702  error( "argument vectors must be same length" ); SWIG_fail;
20703  }
20704  temp29 = args(25).matrix_value();
20705  arg29 = &temp29( 0, 0 );
20706  }
20707  else
20708  {
20709  arg29 = NULL;
20710  }
20711  }
20712  {
20713  if ( _n_dims( args(26) ) > 1 )
20714  {
20715  error( "argument must be a scalar or vector" ); SWIG_fail;
20716  }
20717 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20718  if ( !args(26).isempty() )
20719 #else
20720  if ( !args(26).is_empty() )
20721 #endif
20722  {
20723  if ( _dim( args(26), 0 ) != Alen )
20724  {
20725  error( "argument vectors must be same length" ); SWIG_fail;
20726  }
20727  temp30 = args(26).matrix_value();
20728  arg30 = new PLINT[Alen];
20729  _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
20730  }
20731  else
20732  {
20733  arg30 = NULL;
20734  }
20735  }
20736  {
20737  charMatrix temp_matrix;
20738  Cell temp_cell;
20739  char *tmp_cstring;
20740  std::string str;
20741  size_t max_length = 0, non_blank_length;
20742  int i, ifcell;
20743  if ( _n_dims( args(27) ) > 2 )
20744  {
20745  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20746  }
20747 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20748  if ( !args(27).isempty() )
20749 #else
20750  if ( !args(27).is_empty() )
20751 #endif
20752  {
20753  if ( _dim( args(27), 0 ) != Alen )
20754  {
20755  error( "first dimension must be same length as previous vector" ); SWIG_fail;
20756  }
20757  arg31 = new char*[Alen];
20758 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20759  ifcell = args(27).iscell();
20760 #else
20761  ifcell = args(27).is_cell();
20762 #endif
20763  if ( ifcell )
20764  {
20765  temp_cell = args(27).cell_value();
20766  }
20767  else
20768  {
20769  temp_matrix = args(27).char_matrix_value();
20770  // Allow one extra space for null termination.
20771  max_length = _dim( args(27), 1 ) + 1;
20772  }
20773 
20774  for ( i = 0; i < Alen; i++ )
20775  {
20776  // Must copy string to "permanent" location because the string
20777  // location corresponding to tmp_cstring gets
20778  // overwritten for each iteration of loop.
20779  if ( ifcell )
20780  {
20781  if ( temp_cell.elem( i ).is_string() )
20782  {
20783  str = temp_cell.elem( i ).string_value();
20784  // leave room for null termination.
20785  max_length = str.size() + 1;
20786  tmp_cstring = (char *) str.c_str();
20787  }
20788  else
20789  {
20790  // Use null string if user attempts to pass a cell array
20791  // with a non-string element (likely an empty element
20792  // since that should be allowed by the PLplot interface
20793  // if that element is going to be unused).
20794  // leave room for null termination.
20795  max_length = 1;
20796  tmp_cstring = (char *) "";
20797  }
20798  }
20799  else
20800  {
20801  str = temp_matrix.row_as_string( i );
20802  tmp_cstring = (char *) str.c_str();
20803  }
20804  arg31[i] = new char[max_length];
20805  strncpy( arg31[i], tmp_cstring, max_length - 1 );
20806  arg31[i][max_length - 1] = '\0';
20807  // All the trailing blank crapola should not be needed for
20808  // string cell arrays.
20809  if ( !ifcell )
20810  {
20811  // remove trailing-blank padding that is used by the
20812  // charMatrix class to insure all strings in a given
20813  // charMatrix instance have the same length.
20814  // This transformation also removes legitimate trailing
20815  // blanks but there is nothing we can do about that
20816  // for the charMatrix class.
20817 
20818  // Look for trailing nulls first (just in case, although that
20819  // shouldn't happen if charMatrix implemented as documented)
20820  // before looking for trailing blanks.
20821  non_blank_length = max_length - 2;
20822  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
20823  {
20824  non_blank_length--;
20825  }
20826  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
20827  {
20828  non_blank_length--;
20829  }
20830  arg31[i][non_blank_length + 1] = '\0';
20831  }
20832  }
20833  }
20834  else
20835  {
20836  arg31 = NULL;
20837  }
20838  }
20839  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);
20840  _outv = octave_value();
20841  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20842  if (SWIG_IsTmpObj(res1)) {
20843  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
20844  } else {
20845  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20846  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
20847  }
20848  if (SWIG_IsTmpObj(res2)) {
20849  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
20850  } else {
20851  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20852  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
20853  }
20854  {
20855  delete [] arg14;
20856  }
20857  {
20858  delete [] arg19;
20859  }
20860  {
20861  int i;
20862  if ( arg20 != NULL )
20863  {
20864  for ( i = 0; i < Alen; i++ )
20865  {
20866  delete[] arg20[i];
20867  }
20868  delete[] arg20;
20869  }
20870  }
20871  {
20872  if ( arg21 != NULL )
20873  delete [] arg21;
20874  }
20875  {
20876  if ( arg22 != NULL )
20877  delete [] arg22;
20878  }
20879  {
20880 
20881  }
20882  {
20883 
20884  }
20885  {
20886  if ( arg25 != NULL )
20887  delete [] arg25;
20888  }
20889  {
20890  if ( arg26 != NULL )
20891  delete [] arg26;
20892  }
20893  {
20894 
20895  }
20896  {
20897  if ( arg28 != NULL )
20898  delete [] arg28;
20899  }
20900  {
20901 
20902  }
20903  {
20904  if ( arg30 != NULL )
20905  delete [] arg30;
20906  }
20907  {
20908  int i;
20909  if ( arg31 != NULL )
20910  {
20911  for ( i = 0; i < Alen; i++ )
20912  {
20913  delete[] arg31[i];
20914  }
20915  delete[] arg31;
20916  }
20917  }
20918  return _out;
20919  fail:
20920  {
20921  delete [] arg14;
20922  }
20923  {
20924  delete [] arg19;
20925  }
20926  {
20927  int i;
20928  if ( arg20 != NULL )
20929  {
20930  for ( i = 0; i < Alen; i++ )
20931  {
20932  delete[] arg20[i];
20933  }
20934  delete[] arg20;
20935  }
20936  }
20937  {
20938  if ( arg21 != NULL )
20939  delete [] arg21;
20940  }
20941  {
20942  if ( arg22 != NULL )
20943  delete [] arg22;
20944  }
20945  {
20946 
20947  }
20948  {
20949 
20950  }
20951  {
20952  if ( arg25 != NULL )
20953  delete [] arg25;
20954  }
20955  {
20956  if ( arg26 != NULL )
20957  delete [] arg26;
20958  }
20959  {
20960 
20961  }
20962  {
20963  if ( arg28 != NULL )
20964  delete [] arg28;
20965  }
20966  {
20967 
20968  }
20969  {
20970  if ( arg30 != NULL )
20971  delete [] arg30;
20972  }
20973  {
20974  int i;
20975  if ( arg31 != NULL )
20976  {
20977  for ( i = 0; i < Alen; i++ )
20978  {
20979  delete[] arg31[i];
20980  }
20981  delete[] arg31;
20982  }
20983  }
20984  return octave_value_list();
20985  }
20986  catch(...) {
20987  {
20988  delete [] arg14;
20989  }
20990  {
20991  delete [] arg19;
20992  }
20993  {
20994  int i;
20995  if ( arg20 != NULL )
20996  {
20997  for ( i = 0; i < Alen; i++ )
20998  {
20999  delete[] arg20[i];
21000  }
21001  delete[] arg20;
21002  }
21003  }
21004  {
21005  if ( arg21 != NULL )
21006  delete [] arg21;
21007  }
21008  {
21009  if ( arg22 != NULL )
21010  delete [] arg22;
21011  }
21012  {
21013 
21014  }
21015  {
21016 
21017  }
21018  {
21019  if ( arg25 != NULL )
21020  delete [] arg25;
21021  }
21022  {
21023  if ( arg26 != NULL )
21024  delete [] arg26;
21025  }
21026  {
21027 
21028  }
21029  {
21030  if ( arg28 != NULL )
21031  delete [] arg28;
21032  }
21033  {
21034 
21035  }
21036  {
21037  if ( arg30 != NULL )
21038  delete [] arg30;
21039  }
21040  {
21041  int i;
21042  if ( arg31 != NULL )
21043  {
21044  for ( i = 0; i < Alen; i++ )
21045  {
21046  delete[] arg31[i];
21047  }
21048  delete[] arg31;
21049  }
21050  }
21051  throw;
21052  }
21053 }
21054 
21055 
21057  PLFLT arg1 ;
21058  PLFLT arg2 ;
21059  PLFLT arg3 ;
21060  double val1 ;
21061  int ecode1 = 0 ;
21062  double val2 ;
21063  int ecode2 = 0 ;
21064  double val3 ;
21065  int ecode3 = 0 ;
21066  octave_value_list _out;
21067  octave_value_list *_outp=&_out;
21068  octave_value _outv;
21069 
21070  try {
21071  if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
21072  SWIG_fail;
21073  }
21074  ecode1 = SWIG_AsVal_double(args(0), &val1);
21075  if (!SWIG_IsOK(ecode1)) {
21076  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
21077  }
21078  arg1 = static_cast< PLFLT >(val1);
21079  ecode2 = SWIG_AsVal_double(args(1), &val2);
21080  if (!SWIG_IsOK(ecode2)) {
21081  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
21082  }
21083  arg2 = static_cast< PLFLT >(val2);
21084  ecode3 = SWIG_AsVal_double(args(2), &val3);
21085  if (!SWIG_IsOK(ecode3)) {
21086  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
21087  }
21088  arg3 = static_cast< PLFLT >(val3);
21089  pllightsource(arg1,arg2,arg3);
21090  _outv = octave_value();
21091  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21092  return _out;
21093  fail:
21094  return octave_value_list();
21095  }
21096  catch(...) {
21097  throw;
21098  }
21099 }
21100 
21101 
21103  PLINT arg1 ;
21104  PLFLT *arg2 = (PLFLT *) 0 ;
21105  PLFLT *arg3 = (PLFLT *) 0 ;
21106  Matrix temp1 ;
21107  Matrix temp3 ;
21108  octave_value_list _out;
21109  octave_value_list *_outp=&_out;
21110  octave_value _outv;
21111 
21112  try {
21113  if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
21114  SWIG_fail;
21115  }
21116  {
21117  if ( _n_dims( args(0) ) > 1 )
21118  {
21119  error( "argument must be a scalar or vector" ); SWIG_fail;
21120  }
21121  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21122  temp1 = args(0).matrix_value();
21123  arg2 = &temp1( 0, 0 );
21124  }
21125  {
21126  if ( _n_dims( args(1) ) > 1 )
21127  {
21128  error( "argument must be a scalar or vector" ); SWIG_fail;
21129  }
21130  if ( _dim( args(1), 0 ) != Alen )
21131  {
21132  error( "argument vectors must be same length" ); SWIG_fail;
21133  }
21134  temp3 = args(1).matrix_value();
21135  arg3 = &temp3( 0, 0 );
21136  }
21137  plline(arg1,(double const *)arg2,(double const *)arg3);
21138  _outv = octave_value();
21139  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21140  {
21141 
21142  }
21143  {
21144 
21145  }
21146  return _out;
21147  fail:
21148  {
21149 
21150  }
21151  {
21152 
21153  }
21154  return octave_value_list();
21155  }
21156  catch(...) {
21157  {
21158 
21159  }
21160  {
21161 
21162  }
21163  throw;
21164  }
21165 }
21166 
21167 
21169  PLINT arg1 ;
21170  PLFLT *arg2 = (PLFLT *) 0 ;
21171  PLFLT *arg3 = (PLFLT *) 0 ;
21172  PLFLT *arg4 = (PLFLT *) 0 ;
21173  Matrix temp1 ;
21174  Matrix temp3 ;
21175  Matrix temp4 ;
21176  octave_value_list _out;
21177  octave_value_list *_outp=&_out;
21178  octave_value _outv;
21179 
21180  try {
21181  if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
21182  SWIG_fail;
21183  }
21184  {
21185  if ( _n_dims( args(0) ) > 1 )
21186  {
21187  error( "argument must be a scalar or vector" ); SWIG_fail;
21188  }
21189  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21190  temp1 = args(0).matrix_value();
21191  arg2 = &temp1( 0, 0 );
21192  }
21193  {
21194  if ( _n_dims( args(1) ) > 1 )
21195  {
21196  error( "argument must be a scalar or vector" ); SWIG_fail;
21197  }
21198  if ( _dim( args(1), 0 ) != Alen )
21199  {
21200  error( "argument vectors must be same length" ); SWIG_fail;
21201  }
21202  temp3 = args(1).matrix_value();
21203  arg3 = &temp3( 0, 0 );
21204  }
21205  {
21206  if ( _n_dims( args(2) ) > 1 )
21207  {
21208  error( "argument must be a scalar or vector" ); SWIG_fail;
21209  }
21210  if ( _dim( args(2), 0 ) != Alen )
21211  {
21212  error( "argument vectors must be same length" ); SWIG_fail;
21213  }
21214  temp4 = args(2).matrix_value();
21215  arg4 = &temp4( 0, 0 );
21216  }
21217  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
21218  _outv = octave_value();
21219  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21220  {
21221 
21222  }
21223  {
21224 
21225  }
21226  {
21227 
21228  }
21229  return _out;
21230  fail:
21231  {
21232 
21233  }
21234  {
21235 
21236  }
21237  {
21238 
21239  }
21240  return octave_value_list();
21241  }
21242  catch(...) {
21243  {
21244 
21245  }
21246  {
21247 
21248  }
21249  {
21250 
21251  }
21252  throw;
21253  }
21254 }
21255 
21256 
21258  PLINT arg1 ;
21259  int val1 ;
21260  int ecode1 = 0 ;
21261  octave_value_list _out;
21262  octave_value_list *_outp=&_out;
21263  octave_value _outv;
21264 
21265  try {
21266  if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
21267  SWIG_fail;
21268  }
21269  ecode1 = SWIG_AsVal_int(args(0), &val1);
21270  if (!SWIG_IsOK(ecode1)) {
21271  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
21272  }
21273  arg1 = static_cast< PLINT >(val1);
21274  pllsty(arg1);
21275  _outv = octave_value();
21276  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21277  return _out;
21278  fail:
21279  return octave_value_list();
21280  }
21281  catch(...) {
21282  throw;
21283  }
21284 }
21285 
21286 
21288  PLINT *arg1 = (PLINT *) 0 ;
21289  PLINT temp1 ;
21290  int res1 = SWIG_TMPOBJ ;
21291  octave_value_list _out;
21292  octave_value_list *_outp=&_out;
21293  octave_value _outv;
21294 
21295  try {
21296  arg1 = &temp1;
21297  if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
21298  SWIG_fail;
21299  }
21300  plmkstrm(arg1);
21301  _outv = octave_value();
21302  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21303  if (SWIG_IsTmpObj(res1)) {
21304  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
21305  } else {
21306  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21307  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
21308  }
21309  return _out;
21310  fail:
21311  return octave_value_list();
21312  }
21313  catch(...) {
21314  throw;
21315  }
21316 }
21317 
21318 
21320  char *arg1 = (char *) 0 ;
21321  PLFLT arg2 ;
21322  PLFLT arg3 ;
21323  PLFLT arg4 ;
21324  char *arg5 = (char *) 0 ;
21325  int res1 ;
21326  char *buf1 = 0 ;
21327  int alloc1 = 0 ;
21328  double val2 ;
21329  int ecode2 = 0 ;
21330  double val3 ;
21331  int ecode3 = 0 ;
21332  double val4 ;
21333  int ecode4 = 0 ;
21334  int res5 ;
21335  char *buf5 = 0 ;
21336  int alloc5 = 0 ;
21337  octave_value_list _out;
21338  octave_value_list *_outp=&_out;
21339  octave_value _outv;
21340 
21341  try {
21342  if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
21343  SWIG_fail;
21344  }
21345  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21346  if (!SWIG_IsOK(res1)) {
21347  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
21348  }
21349  arg1 = reinterpret_cast< char * >(buf1);
21350  ecode2 = SWIG_AsVal_double(args(1), &val2);
21351  if (!SWIG_IsOK(ecode2)) {
21352  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
21353  }
21354  arg2 = static_cast< PLFLT >(val2);
21355  ecode3 = SWIG_AsVal_double(args(2), &val3);
21356  if (!SWIG_IsOK(ecode3)) {
21357  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
21358  }
21359  arg3 = static_cast< PLFLT >(val3);
21360  ecode4 = SWIG_AsVal_double(args(3), &val4);
21361  if (!SWIG_IsOK(ecode4)) {
21362  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
21363  }
21364  arg4 = static_cast< PLFLT >(val4);
21365  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21366  if (!SWIG_IsOK(res5)) {
21367  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
21368  }
21369  arg5 = reinterpret_cast< char * >(buf5);
21370  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21371  _outv = octave_value();
21372  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21373  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21374  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21375  return _out;
21376  fail:
21377  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21378  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21379  return octave_value_list();
21380  }
21381  catch(...) {
21382  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21383  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21384  throw;
21385  }
21386 }
21387 
21388 
21390  char *arg1 = (char *) 0 ;
21391  PLFLT arg2 ;
21392  PLFLT arg3 ;
21393  PLFLT arg4 ;
21394  char *arg5 = (char *) 0 ;
21395  int res1 ;
21396  char *buf1 = 0 ;
21397  int alloc1 = 0 ;
21398  double val2 ;
21399  int ecode2 = 0 ;
21400  double val3 ;
21401  int ecode3 = 0 ;
21402  double val4 ;
21403  int ecode4 = 0 ;
21404  int res5 ;
21405  char *buf5 = 0 ;
21406  int alloc5 = 0 ;
21407  octave_value_list _out;
21408  octave_value_list *_outp=&_out;
21409  octave_value _outv;
21410 
21411  try {
21412  if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
21413  SWIG_fail;
21414  }
21415  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21416  if (!SWIG_IsOK(res1)) {
21417  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
21418  }
21419  arg1 = reinterpret_cast< char * >(buf1);
21420  ecode2 = SWIG_AsVal_double(args(1), &val2);
21421  if (!SWIG_IsOK(ecode2)) {
21422  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
21423  }
21424  arg2 = static_cast< PLFLT >(val2);
21425  ecode3 = SWIG_AsVal_double(args(2), &val3);
21426  if (!SWIG_IsOK(ecode3)) {
21427  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
21428  }
21429  arg3 = static_cast< PLFLT >(val3);
21430  ecode4 = SWIG_AsVal_double(args(3), &val4);
21431  if (!SWIG_IsOK(ecode4)) {
21432  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
21433  }
21434  arg4 = static_cast< PLFLT >(val4);
21435  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21436  if (!SWIG_IsOK(res5)) {
21437  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
21438  }
21439  arg5 = reinterpret_cast< char * >(buf5);
21440  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21441  _outv = octave_value();
21442  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21443  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21444  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21445  return _out;
21446  fail:
21447  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21448  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21449  return octave_value_list();
21450  }
21451  catch(...) {
21452  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21453  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21454  throw;
21455  }
21456 }
21457 
21458 
21460  int *arg1 = (int *) 0 ;
21461  char **arg2 = (char **) 0 ;
21462  PLINT arg3 ;
21463  void *argp1 = 0 ;
21464  int res1 = 0 ;
21465  void *argp2 = 0 ;
21466  int res2 = 0 ;
21467  int val3 ;
21468  int ecode3 = 0 ;
21469  octave_value_list _out;
21470  octave_value_list *_outp=&_out;
21471  octave_value _outv;
21472  PLINT result;
21473 
21474  try {
21475  if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
21476  SWIG_fail;
21477  }
21478  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
21479  if (!SWIG_IsOK(res1)) {
21480  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
21481  }
21482  arg1 = reinterpret_cast< int * >(argp1);
21483  res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
21484  if (!SWIG_IsOK(res2)) {
21485  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
21486  }
21487  arg2 = reinterpret_cast< char ** >(argp2);
21488  ecode3 = SWIG_AsVal_int(args(2), &val3);
21489  if (!SWIG_IsOK(ecode3)) {
21490  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
21491  }
21492  arg3 = static_cast< PLINT >(val3);
21493  result = (PLINT)plparseopts(arg1,arg2,arg3);
21494  _outv = SWIG_From_int(static_cast< int >(result));
21495  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21496  return _out;
21497  fail:
21498  return octave_value_list();
21499  }
21500  catch(...) {
21501  throw;
21502  }
21503 }
21504 
21505 
21507  PLINT arg1 ;
21508  PLINT *arg2 = (PLINT *) 0 ;
21509  PLINT *arg3 = (PLINT *) 0 ;
21510  Matrix temp1 ;
21511  Matrix temp3 ;
21512  octave_value_list _out;
21513  octave_value_list *_outp=&_out;
21514  octave_value _outv;
21515 
21516  try {
21517  if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
21518  SWIG_fail;
21519  }
21520  {
21521  if ( _n_dims( args(0) ) > 1 )
21522  {
21523  error( "argument must be a scalar or vector" ); SWIG_fail;
21524  }
21525  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21526  arg2 = new PLINT[Alen];
21527  temp1 = args(0).matrix_value();
21528  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21529  }
21530  {
21531  if ( _n_dims( args(1) ) > 1 )
21532  {
21533  error( "argument must be a scalar or vector" ); SWIG_fail;
21534  }
21535  if ( _dim( args(1), 0 ) != Alen )
21536  {
21537  error( "argument vectors must be same length" ); SWIG_fail;
21538  }
21539  temp3 = args(1).matrix_value();
21540  arg3 = new PLINT[Alen];
21541  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21542  }
21543  plpat(arg1,(int const *)arg2,(int const *)arg3);
21544  _outv = octave_value();
21545  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21546  {
21547  delete [] arg2;
21548  }
21549  {
21550  delete [] arg3;
21551  }
21552  return _out;
21553  fail:
21554  {
21555  delete [] arg2;
21556  }
21557  {
21558  delete [] arg3;
21559  }
21560  return octave_value_list();
21561  }
21562  catch(...) {
21563  {
21564  delete [] arg2;
21565  }
21566  {
21567  delete [] arg3;
21568  }
21569  throw;
21570  }
21571 }
21572 
21573 
21575  PLINT arg1 ;
21576  PLFLT arg2 ;
21577  PLFLT arg3 ;
21578  PLFLT arg4 ;
21579  PLFLT arg5 ;
21580  int val1 ;
21581  int ecode1 = 0 ;
21582  double val2 ;
21583  int ecode2 = 0 ;
21584  double val3 ;
21585  int ecode3 = 0 ;
21586  double val4 ;
21587  int ecode4 = 0 ;
21588  double val5 ;
21589  int ecode5 = 0 ;
21590  octave_value_list _out;
21591  octave_value_list *_outp=&_out;
21592  octave_value _outv;
21593 
21594  try {
21595  if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
21596  SWIG_fail;
21597  }
21598  ecode1 = SWIG_AsVal_int(args(0), &val1);
21599  if (!SWIG_IsOK(ecode1)) {
21600  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
21601  }
21602  arg1 = static_cast< PLINT >(val1);
21603  ecode2 = SWIG_AsVal_double(args(1), &val2);
21604  if (!SWIG_IsOK(ecode2)) {
21605  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
21606  }
21607  arg2 = static_cast< PLFLT >(val2);
21608  ecode3 = SWIG_AsVal_double(args(2), &val3);
21609  if (!SWIG_IsOK(ecode3)) {
21610  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
21611  }
21612  arg3 = static_cast< PLFLT >(val3);
21613  ecode4 = SWIG_AsVal_double(args(3), &val4);
21614  if (!SWIG_IsOK(ecode4)) {
21615  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
21616  }
21617  arg4 = static_cast< PLFLT >(val4);
21618  ecode5 = SWIG_AsVal_double(args(4), &val5);
21619  if (!SWIG_IsOK(ecode5)) {
21620  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
21621  }
21622  arg5 = static_cast< PLFLT >(val5);
21623  plpath(arg1,arg2,arg3,arg4,arg5);
21624  _outv = octave_value();
21625  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21626  return _out;
21627  fail:
21628  return octave_value_list();
21629  }
21630  catch(...) {
21631  throw;
21632  }
21633 }
21634 
21635 
21637  PLINT arg1 ;
21638  PLFLT *arg2 = (PLFLT *) 0 ;
21639  PLFLT *arg3 = (PLFLT *) 0 ;
21640  PLINT arg4 ;
21641  Matrix temp1 ;
21642  Matrix temp3 ;
21643  int val4 ;
21644  int ecode4 = 0 ;
21645  octave_value_list _out;
21646  octave_value_list *_outp=&_out;
21647  octave_value _outv;
21648 
21649  try {
21650  if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
21651  SWIG_fail;
21652  }
21653  {
21654  if ( _n_dims( args(0) ) > 1 )
21655  {
21656  error( "argument must be a scalar or vector" ); SWIG_fail;
21657  }
21658  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21659  temp1 = args(0).matrix_value();
21660  arg2 = &temp1( 0, 0 );
21661  }
21662  {
21663  if ( _n_dims( args(1) ) > 1 )
21664  {
21665  error( "argument must be a scalar or vector" ); SWIG_fail;
21666  }
21667  if ( _dim( args(1), 0 ) != Alen )
21668  {
21669  error( "argument vectors must be same length" ); SWIG_fail;
21670  }
21671  temp3 = args(1).matrix_value();
21672  arg3 = &temp3( 0, 0 );
21673  }
21674  ecode4 = SWIG_AsVal_int(args(2), &val4);
21675  if (!SWIG_IsOK(ecode4)) {
21676  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
21677  }
21678  arg4 = static_cast< PLINT >(val4);
21679  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
21680  _outv = octave_value();
21681  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21682  {
21683 
21684  }
21685  {
21686 
21687  }
21688  return _out;
21689  fail:
21690  {
21691 
21692  }
21693  {
21694 
21695  }
21696  return octave_value_list();
21697  }
21698  catch(...) {
21699  {
21700 
21701  }
21702  {
21703 
21704  }
21705  throw;
21706  }
21707 }
21708 
21709 
21711  PLINT arg1 ;
21712  PLFLT *arg2 = (PLFLT *) 0 ;
21713  PLFLT *arg3 = (PLFLT *) 0 ;
21714  PLFLT *arg4 = (PLFLT *) 0 ;
21715  PLINT arg5 ;
21716  Matrix temp1 ;
21717  Matrix temp3 ;
21718  Matrix temp4 ;
21719  int val5 ;
21720  int ecode5 = 0 ;
21721  octave_value_list _out;
21722  octave_value_list *_outp=&_out;
21723  octave_value _outv;
21724 
21725  try {
21726  if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
21727  SWIG_fail;
21728  }
21729  {
21730  if ( _n_dims( args(0) ) > 1 )
21731  {
21732  error( "argument must be a scalar or vector" ); SWIG_fail;
21733  }
21734  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21735  temp1 = args(0).matrix_value();
21736  arg2 = &temp1( 0, 0 );
21737  }
21738  {
21739  if ( _n_dims( args(1) ) > 1 )
21740  {
21741  error( "argument must be a scalar or vector" ); SWIG_fail;
21742  }
21743  if ( _dim( args(1), 0 ) != Alen )
21744  {
21745  error( "argument vectors must be same length" ); SWIG_fail;
21746  }
21747  temp3 = args(1).matrix_value();
21748  arg3 = &temp3( 0, 0 );
21749  }
21750  {
21751  if ( _n_dims( args(2) ) > 1 )
21752  {
21753  error( "argument must be a scalar or vector" ); SWIG_fail;
21754  }
21755  if ( _dim( args(2), 0 ) != Alen )
21756  {
21757  error( "argument vectors must be same length" ); SWIG_fail;
21758  }
21759  temp4 = args(2).matrix_value();
21760  arg4 = &temp4( 0, 0 );
21761  }
21762  ecode5 = SWIG_AsVal_int(args(3), &val5);
21763  if (!SWIG_IsOK(ecode5)) {
21764  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
21765  }
21766  arg5 = static_cast< PLINT >(val5);
21767  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
21768  _outv = octave_value();
21769  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21770  {
21771 
21772  }
21773  {
21774 
21775  }
21776  {
21777 
21778  }
21779  return _out;
21780  fail:
21781  {
21782 
21783  }
21784  {
21785 
21786  }
21787  {
21788 
21789  }
21790  return octave_value_list();
21791  }
21792  catch(...) {
21793  {
21794 
21795  }
21796  {
21797 
21798  }
21799  {
21800 
21801  }
21802  throw;
21803  }
21804 }
21805 
21806 
21808  PLINT arg1 ;
21809  PLFLT *arg2 = (PLFLT *) 0 ;
21810  PLFLT *arg3 = (PLFLT *) 0 ;
21811  PLFLT *arg4 = (PLFLT *) 0 ;
21812  PLBOOL *arg5 = (PLBOOL *) 0 ;
21813  PLBOOL arg6 ;
21814  Matrix temp1 ;
21815  Matrix temp3 ;
21816  Matrix temp4 ;
21817  Matrix temp5 ;
21818  int val6 ;
21819  int ecode6 = 0 ;
21820  octave_value_list _out;
21821  octave_value_list *_outp=&_out;
21822  octave_value _outv;
21823 
21824  try {
21825  if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
21826  SWIG_fail;
21827  }
21828  {
21829  if ( _n_dims( args(0) ) > 1 )
21830  {
21831  error( "argument must be a scalar or vector" ); SWIG_fail;
21832  }
21833  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21834  temp1 = args(0).matrix_value();
21835  arg2 = &temp1( 0, 0 );
21836  }
21837  {
21838  if ( _n_dims( args(1) ) > 1 )
21839  {
21840  error( "argument must be a scalar or vector" ); SWIG_fail;
21841  }
21842  if ( _dim( args(1), 0 ) != Alen )
21843  {
21844  error( "argument vectors must be same length" ); SWIG_fail;
21845  }
21846  temp3 = args(1).matrix_value();
21847  arg3 = &temp3( 0, 0 );
21848  }
21849  {
21850  if ( _n_dims( args(2) ) > 1 )
21851  {
21852  error( "argument must be a scalar or vector" ); SWIG_fail;
21853  }
21854  if ( _dim( args(2), 0 ) != Alen )
21855  {
21856  error( "argument vectors must be same length" ); SWIG_fail;
21857  }
21858  temp4 = args(2).matrix_value();
21859  arg4 = &temp4( 0, 0 );
21860  }
21861  {
21862  if ( _n_dims( args(3) ) > 1 )
21863  {
21864  error( "argument must be a scalar or vector" ); SWIG_fail;
21865  }
21866  if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
21867  {
21868  error( "argument vector must be same length or one less" ); SWIG_fail;
21869  }
21870  temp5 = args(3).matrix_value();
21871  arg5 = new PLINT[Alen];
21872  _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
21873  }
21874  ecode6 = SWIG_AsVal_int(args(4), &val6);
21875  if (!SWIG_IsOK(ecode6)) {
21876  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
21877  }
21878  arg6 = static_cast< PLBOOL >(val6);
21879  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
21880  _outv = octave_value();
21881  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21882  {
21883 
21884  }
21885  {
21886 
21887  }
21888  {
21889 
21890  }
21891  {
21892  delete [] arg5;
21893  }
21894  return _out;
21895  fail:
21896  {
21897 
21898  }
21899  {
21900 
21901  }
21902  {
21903 
21904  }
21905  {
21906  delete [] arg5;
21907  }
21908  return octave_value_list();
21909  }
21910  catch(...) {
21911  {
21912 
21913  }
21914  {
21915 
21916  }
21917  {
21918 
21919  }
21920  {
21921  delete [] arg5;
21922  }
21923  throw;
21924  }
21925 }
21926 
21927 
21929  PLINT arg1 ;
21930  PLINT arg2 ;
21931  int val1 ;
21932  int ecode1 = 0 ;
21933  int val2 ;
21934  int ecode2 = 0 ;
21935  octave_value_list _out;
21936  octave_value_list *_outp=&_out;
21937  octave_value _outv;
21938 
21939  try {
21940  if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
21941  SWIG_fail;
21942  }
21943  ecode1 = SWIG_AsVal_int(args(0), &val1);
21944  if (!SWIG_IsOK(ecode1)) {
21945  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
21946  }
21947  arg1 = static_cast< PLINT >(val1);
21948  ecode2 = SWIG_AsVal_int(args(1), &val2);
21949  if (!SWIG_IsOK(ecode2)) {
21950  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
21951  }
21952  arg2 = static_cast< PLINT >(val2);
21953  plprec(arg1,arg2);
21954  _outv = octave_value();
21955  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21956  return _out;
21957  fail:
21958  return octave_value_list();
21959  }
21960  catch(...) {
21961  throw;
21962  }
21963 }
21964 
21965 
21967  PLINT arg1 ;
21968  int val1 ;
21969  int ecode1 = 0 ;
21970  octave_value_list _out;
21971  octave_value_list *_outp=&_out;
21972  octave_value _outv;
21973 
21974  try {
21975  if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
21976  SWIG_fail;
21977  }
21978  ecode1 = SWIG_AsVal_int(args(0), &val1);
21979  if (!SWIG_IsOK(ecode1)) {
21980  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
21981  }
21982  arg1 = static_cast< PLINT >(val1);
21983  plpsty(arg1);
21984  _outv = octave_value();
21985  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21986  return _out;
21987  fail:
21988  return octave_value_list();
21989  }
21990  catch(...) {
21991  throw;
21992  }
21993 }
21994 
21995 
21997  PLFLT arg1 ;
21998  PLFLT arg2 ;
21999  PLFLT arg3 ;
22000  PLFLT arg4 ;
22001  PLFLT arg5 ;
22002  char *arg6 = (char *) 0 ;
22003  double val1 ;
22004  int ecode1 = 0 ;
22005  double val2 ;
22006  int ecode2 = 0 ;
22007  double val3 ;
22008  int ecode3 = 0 ;
22009  double val4 ;
22010  int ecode4 = 0 ;
22011  double val5 ;
22012  int ecode5 = 0 ;
22013  int res6 ;
22014  char *buf6 = 0 ;
22015  int alloc6 = 0 ;
22016  octave_value_list _out;
22017  octave_value_list *_outp=&_out;
22018  octave_value _outv;
22019 
22020  try {
22021  if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
22022  SWIG_fail;
22023  }
22024  ecode1 = SWIG_AsVal_double(args(0), &val1);
22025  if (!SWIG_IsOK(ecode1)) {
22026  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
22027  }
22028  arg1 = static_cast< PLFLT >(val1);
22029  ecode2 = SWIG_AsVal_double(args(1), &val2);
22030  if (!SWIG_IsOK(ecode2)) {
22031  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
22032  }
22033  arg2 = static_cast< PLFLT >(val2);
22034  ecode3 = SWIG_AsVal_double(args(2), &val3);
22035  if (!SWIG_IsOK(ecode3)) {
22036  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
22037  }
22038  arg3 = static_cast< PLFLT >(val3);
22039  ecode4 = SWIG_AsVal_double(args(3), &val4);
22040  if (!SWIG_IsOK(ecode4)) {
22041  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
22042  }
22043  arg4 = static_cast< PLFLT >(val4);
22044  ecode5 = SWIG_AsVal_double(args(4), &val5);
22045  if (!SWIG_IsOK(ecode5)) {
22046  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
22047  }
22048  arg5 = static_cast< PLFLT >(val5);
22049  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22050  if (!SWIG_IsOK(res6)) {
22051  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
22052  }
22053  arg6 = reinterpret_cast< char * >(buf6);
22054  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
22055  _outv = octave_value();
22056  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22057  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22058  return _out;
22059  fail:
22060  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22061  return octave_value_list();
22062  }
22063  catch(...) {
22064  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22065  throw;
22066  }
22067 }
22068 
22069 
22071  PLFLT arg1 ;
22072  PLFLT arg2 ;
22073  PLFLT arg3 ;
22074  PLFLT arg4 ;
22075  PLFLT arg5 ;
22076  PLFLT arg6 ;
22077  PLFLT arg7 ;
22078  PLFLT arg8 ;
22079  PLFLT arg9 ;
22080  PLFLT arg10 ;
22081  char *arg11 = (char *) 0 ;
22082  double val1 ;
22083  int ecode1 = 0 ;
22084  double val2 ;
22085  int ecode2 = 0 ;
22086  double val3 ;
22087  int ecode3 = 0 ;
22088  double val4 ;
22089  int ecode4 = 0 ;
22090  double val5 ;
22091  int ecode5 = 0 ;
22092  double val6 ;
22093  int ecode6 = 0 ;
22094  double val7 ;
22095  int ecode7 = 0 ;
22096  double val8 ;
22097  int ecode8 = 0 ;
22098  double val9 ;
22099  int ecode9 = 0 ;
22100  double val10 ;
22101  int ecode10 = 0 ;
22102  int res11 ;
22103  char *buf11 = 0 ;
22104  int alloc11 = 0 ;
22105  octave_value_list _out;
22106  octave_value_list *_outp=&_out;
22107  octave_value _outv;
22108 
22109  try {
22110  if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
22111  SWIG_fail;
22112  }
22113  ecode1 = SWIG_AsVal_double(args(0), &val1);
22114  if (!SWIG_IsOK(ecode1)) {
22115  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
22116  }
22117  arg1 = static_cast< PLFLT >(val1);
22118  ecode2 = SWIG_AsVal_double(args(1), &val2);
22119  if (!SWIG_IsOK(ecode2)) {
22120  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
22121  }
22122  arg2 = static_cast< PLFLT >(val2);
22123  ecode3 = SWIG_AsVal_double(args(2), &val3);
22124  if (!SWIG_IsOK(ecode3)) {
22125  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
22126  }
22127  arg3 = static_cast< PLFLT >(val3);
22128  ecode4 = SWIG_AsVal_double(args(3), &val4);
22129  if (!SWIG_IsOK(ecode4)) {
22130  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
22131  }
22132  arg4 = static_cast< PLFLT >(val4);
22133  ecode5 = SWIG_AsVal_double(args(4), &val5);
22134  if (!SWIG_IsOK(ecode5)) {
22135  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
22136  }
22137  arg5 = static_cast< PLFLT >(val5);
22138  ecode6 = SWIG_AsVal_double(args(5), &val6);
22139  if (!SWIG_IsOK(ecode6)) {
22140  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
22141  }
22142  arg6 = static_cast< PLFLT >(val6);
22143  ecode7 = SWIG_AsVal_double(args(6), &val7);
22144  if (!SWIG_IsOK(ecode7)) {
22145  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
22146  }
22147  arg7 = static_cast< PLFLT >(val7);
22148  ecode8 = SWIG_AsVal_double(args(7), &val8);
22149  if (!SWIG_IsOK(ecode8)) {
22150  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
22151  }
22152  arg8 = static_cast< PLFLT >(val8);
22153  ecode9 = SWIG_AsVal_double(args(8), &val9);
22154  if (!SWIG_IsOK(ecode9)) {
22155  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
22156  }
22157  arg9 = static_cast< PLFLT >(val9);
22158  ecode10 = SWIG_AsVal_double(args(9), &val10);
22159  if (!SWIG_IsOK(ecode10)) {
22160  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
22161  }
22162  arg10 = static_cast< PLFLT >(val10);
22163  res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
22164  if (!SWIG_IsOK(res11)) {
22165  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
22166  }
22167  arg11 = reinterpret_cast< char * >(buf11);
22168  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
22169  _outv = octave_value();
22170  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22171  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22172  return _out;
22173  fail:
22174  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22175  return octave_value_list();
22176  }
22177  catch(...) {
22178  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22179  throw;
22180  }
22181 }
22182 
22183 
22185  octave_value_list _out;
22186  octave_value_list *_outp=&_out;
22187  octave_value _outv;
22188  PLFLT result;
22189 
22190  try {
22191  if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
22192  SWIG_fail;
22193  }
22194  result = (PLFLT)plrandd();
22195  _outv = SWIG_From_double(static_cast< double >(result));
22196  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22197  return _out;
22198  fail:
22199  return octave_value_list();
22200  }
22201  catch(...) {
22202  throw;
22203  }
22204 }
22205 
22206 
22208  octave_value_list _out;
22209  octave_value_list *_outp=&_out;
22210  octave_value _outv;
22211 
22212  try {
22213  if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
22214  SWIG_fail;
22215  }
22216  plreplot();
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  catch(...) {
22224  throw;
22225  }
22226 }
22227 
22228 
22230  PLFLT arg1 ;
22231  PLFLT arg2 ;
22232  PLFLT arg3 ;
22233  PLFLT *arg4 = (PLFLT *) 0 ;
22234  PLFLT *arg5 = (PLFLT *) 0 ;
22235  PLFLT *arg6 = (PLFLT *) 0 ;
22236  double val1 ;
22237  int ecode1 = 0 ;
22238  double val2 ;
22239  int ecode2 = 0 ;
22240  double val3 ;
22241  int ecode3 = 0 ;
22242  PLFLT temp4 ;
22243  int res4 = SWIG_TMPOBJ ;
22244  PLFLT temp5 ;
22245  int res5 = SWIG_TMPOBJ ;
22246  PLFLT temp6 ;
22247  int res6 = SWIG_TMPOBJ ;
22248  octave_value_list _out;
22249  octave_value_list *_outp=&_out;
22250  octave_value _outv;
22251 
22252  try {
22253  arg4 = &temp4;
22254  arg5 = &temp5;
22255  arg6 = &temp6;
22256  if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
22257  SWIG_fail;
22258  }
22259  ecode1 = SWIG_AsVal_double(args(0), &val1);
22260  if (!SWIG_IsOK(ecode1)) {
22261  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
22262  }
22263  arg1 = static_cast< PLFLT >(val1);
22264  ecode2 = SWIG_AsVal_double(args(1), &val2);
22265  if (!SWIG_IsOK(ecode2)) {
22266  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
22267  }
22268  arg2 = static_cast< PLFLT >(val2);
22269  ecode3 = SWIG_AsVal_double(args(2), &val3);
22270  if (!SWIG_IsOK(ecode3)) {
22271  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
22272  }
22273  arg3 = static_cast< PLFLT >(val3);
22274  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22275  _outv = octave_value();
22276  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22277  if (SWIG_IsTmpObj(res4)) {
22278  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
22279  } else {
22280  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22281  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
22282  }
22283  if (SWIG_IsTmpObj(res5)) {
22284  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
22285  } else {
22286  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22287  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
22288  }
22289  if (SWIG_IsTmpObj(res6)) {
22290  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
22291  } else {
22292  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22293  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
22294  }
22295  return _out;
22296  fail:
22297  return octave_value_list();
22298  }
22299  catch(...) {
22300  throw;
22301  }
22302 }
22303 
22304 
22306  PLFLT arg1 ;
22307  PLFLT arg2 ;
22308  double val1 ;
22309  int ecode1 = 0 ;
22310  double val2 ;
22311  int ecode2 = 0 ;
22312  octave_value_list _out;
22313  octave_value_list *_outp=&_out;
22314  octave_value _outv;
22315 
22316  try {
22317  if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
22318  SWIG_fail;
22319  }
22320  ecode1 = SWIG_AsVal_double(args(0), &val1);
22321  if (!SWIG_IsOK(ecode1)) {
22322  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
22323  }
22324  arg1 = static_cast< PLFLT >(val1);
22325  ecode2 = SWIG_AsVal_double(args(1), &val2);
22326  if (!SWIG_IsOK(ecode2)) {
22327  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
22328  }
22329  arg2 = static_cast< PLFLT >(val2);
22330  plschr(arg1,arg2);
22331  _outv = octave_value();
22332  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22333  return _out;
22334  fail:
22335  return octave_value_list();
22336  }
22337  catch(...) {
22338  throw;
22339  }
22340 }
22341 
22342 
22344  PLINT *arg1 = (PLINT *) 0 ;
22345  PLINT *arg2 = (PLINT *) 0 ;
22346  PLINT *arg3 = (PLINT *) 0 ;
22347  PLINT arg4 ;
22348  Matrix temp1 ;
22349  Matrix temp2 ;
22350  Matrix temp3 ;
22351  octave_value_list _out;
22352  octave_value_list *_outp=&_out;
22353  octave_value _outv;
22354 
22355  try {
22356  if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
22357  SWIG_fail;
22358  }
22359  {
22360  if ( _n_dims( args(0) ) > 1 )
22361  {
22362  error( "argument must be a scalar or vector" ); SWIG_fail;
22363  }
22364  Alen = (PLINT) ( _dim( args(0), 0 ) );
22365  temp1 = args(0).matrix_value();
22366  arg1 = new PLINT[Alen];
22367  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22368  }
22369  {
22370  if ( _n_dims( args(1) ) > 1 )
22371  {
22372  error( "argument must be a scalar or vector" ); SWIG_fail;
22373  }
22374  if ( _dim( args(1), 0 ) != Alen )
22375  {
22376  error( "argument vectors must be same length" ); SWIG_fail;
22377  }
22378  temp2 = args(1).matrix_value();
22379  arg2 = new PLINT[Alen];
22380  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22381  }
22382  {
22383  if ( _n_dims( args(2) ) > 1 )
22384  {
22385  error( "argument must be a scalar or vector" ); SWIG_fail;
22386  }
22387  if ( _dim( args(2), 0 ) != Alen )
22388  {
22389  error( "argument vectors must be same length" ); SWIG_fail;
22390  }
22391  temp3 = args(2).matrix_value();
22392  arg3 = new PLINT[Alen];
22393  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22394  arg4 = Alen;
22395  }
22396  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22397  _outv = octave_value();
22398  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22399  {
22400  delete [] arg1;
22401  }
22402  {
22403  delete [] arg2;
22404  }
22405  {
22406  delete [] arg3;
22407  }
22408  return _out;
22409  fail:
22410  {
22411  delete [] arg1;
22412  }
22413  {
22414  delete [] arg2;
22415  }
22416  {
22417  delete [] arg3;
22418  }
22419  return octave_value_list();
22420  }
22421  catch(...) {
22422  {
22423  delete [] arg1;
22424  }
22425  {
22426  delete [] arg2;
22427  }
22428  {
22429  delete [] arg3;
22430  }
22431  throw;
22432  }
22433 }
22434 
22435 
22437  PLINT *arg1 = (PLINT *) 0 ;
22438  PLINT *arg2 = (PLINT *) 0 ;
22439  PLINT *arg3 = (PLINT *) 0 ;
22440  PLFLT *arg4 = (PLFLT *) 0 ;
22441  PLINT arg5 ;
22442  Matrix temp1 ;
22443  Matrix temp2 ;
22444  Matrix temp3 ;
22445  Matrix temp4 ;
22446  octave_value_list _out;
22447  octave_value_list *_outp=&_out;
22448  octave_value _outv;
22449 
22450  try {
22451  if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
22452  SWIG_fail;
22453  }
22454  {
22455  if ( _n_dims( args(0) ) > 1 )
22456  {
22457  error( "argument must be a scalar or vector" ); SWIG_fail;
22458  }
22459  Alen = (PLINT) ( _dim( args(0), 0 ) );
22460  temp1 = args(0).matrix_value();
22461  arg1 = new PLINT[Alen];
22462  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22463  }
22464  {
22465  if ( _n_dims( args(1) ) > 1 )
22466  {
22467  error( "argument must be a scalar or vector" ); SWIG_fail;
22468  }
22469  if ( _dim( args(1), 0 ) != Alen )
22470  {
22471  error( "argument vectors must be same length" ); SWIG_fail;
22472  }
22473  temp2 = args(1).matrix_value();
22474  arg2 = new PLINT[Alen];
22475  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22476  }
22477  {
22478  if ( _n_dims( args(2) ) > 1 )
22479  {
22480  error( "argument must be a scalar or vector" ); SWIG_fail;
22481  }
22482  if ( _dim( args(2), 0 ) != Alen )
22483  {
22484  error( "argument vectors must be same length" ); SWIG_fail;
22485  }
22486  temp3 = args(2).matrix_value();
22487  arg3 = new PLINT[Alen];
22488  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22489  }
22490  {
22491  if ( _n_dims( args(3) ) > 1 )
22492  {
22493  error( "argument must be a scalar or vector" ); SWIG_fail;
22494  }
22495  if ( _dim( args(3), 0 ) != Alen )
22496  {
22497  error( "argument vectors must be same length" ); SWIG_fail;
22498  }
22499  temp4 = args(3).matrix_value();
22500  arg4 = &temp4( 0, 0 );
22501  arg5 = (PLINT) ( _dim( args(3), 0 ) );
22502  }
22503  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22504  _outv = octave_value();
22505  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22506  {
22507  delete [] arg1;
22508  }
22509  {
22510  delete [] arg2;
22511  }
22512  {
22513  delete [] arg3;
22514  }
22515  {
22516 
22517  }
22518  return _out;
22519  fail:
22520  {
22521  delete [] arg1;
22522  }
22523  {
22524  delete [] arg2;
22525  }
22526  {
22527  delete [] arg3;
22528  }
22529  {
22530 
22531  }
22532  return octave_value_list();
22533  }
22534  catch(...) {
22535  {
22536  delete [] arg1;
22537  }
22538  {
22539  delete [] arg2;
22540  }
22541  {
22542  delete [] arg3;
22543  }
22544  {
22545 
22546  }
22547  throw;
22548  }
22549 }
22550 
22551 
22553  PLINT arg1 ;
22554  int val1 ;
22555  int ecode1 = 0 ;
22556  octave_value_list _out;
22557  octave_value_list *_outp=&_out;
22558  octave_value _outv;
22559 
22560  try {
22561  if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
22562  SWIG_fail;
22563  }
22564  ecode1 = SWIG_AsVal_int(args(0), &val1);
22565  if (!SWIG_IsOK(ecode1)) {
22566  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
22567  }
22568  arg1 = static_cast< PLINT >(val1);
22569  plscmap0n(arg1);
22570  _outv = octave_value();
22571  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22572  return _out;
22573  fail:
22574  return octave_value_list();
22575  }
22576  catch(...) {
22577  throw;
22578  }
22579 }
22580 
22581 
22583  PLINT *arg1 = (PLINT *) 0 ;
22584  PLINT *arg2 = (PLINT *) 0 ;
22585  PLINT *arg3 = (PLINT *) 0 ;
22586  PLINT arg4 ;
22587  Matrix temp1 ;
22588  Matrix temp2 ;
22589  Matrix temp3 ;
22590  octave_value_list _out;
22591  octave_value_list *_outp=&_out;
22592  octave_value _outv;
22593 
22594  try {
22595  if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
22596  SWIG_fail;
22597  }
22598  {
22599  if ( _n_dims( args(0) ) > 1 )
22600  {
22601  error( "argument must be a scalar or vector" ); SWIG_fail;
22602  }
22603  Alen = (PLINT) ( _dim( args(0), 0 ) );
22604  temp1 = args(0).matrix_value();
22605  arg1 = new PLINT[Alen];
22606  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22607  }
22608  {
22609  if ( _n_dims( args(1) ) > 1 )
22610  {
22611  error( "argument must be a scalar or vector" ); SWIG_fail;
22612  }
22613  if ( _dim( args(1), 0 ) != Alen )
22614  {
22615  error( "argument vectors must be same length" ); SWIG_fail;
22616  }
22617  temp2 = args(1).matrix_value();
22618  arg2 = new PLINT[Alen];
22619  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22620  }
22621  {
22622  if ( _n_dims( args(2) ) > 1 )
22623  {
22624  error( "argument must be a scalar or vector" ); SWIG_fail;
22625  }
22626  if ( _dim( args(2), 0 ) != Alen )
22627  {
22628  error( "argument vectors must be same length" ); SWIG_fail;
22629  }
22630  temp3 = args(2).matrix_value();
22631  arg3 = new PLINT[Alen];
22632  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22633  arg4 = Alen;
22634  }
22635  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22636  _outv = octave_value();
22637  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22638  {
22639  delete [] arg1;
22640  }
22641  {
22642  delete [] arg2;
22643  }
22644  {
22645  delete [] arg3;
22646  }
22647  return _out;
22648  fail:
22649  {
22650  delete [] arg1;
22651  }
22652  {
22653  delete [] arg2;
22654  }
22655  {
22656  delete [] arg3;
22657  }
22658  return octave_value_list();
22659  }
22660  catch(...) {
22661  {
22662  delete [] arg1;
22663  }
22664  {
22665  delete [] arg2;
22666  }
22667  {
22668  delete [] arg3;
22669  }
22670  throw;
22671  }
22672 }
22673 
22674 
22676  PLINT *arg1 = (PLINT *) 0 ;
22677  PLINT *arg2 = (PLINT *) 0 ;
22678  PLINT *arg3 = (PLINT *) 0 ;
22679  PLFLT *arg4 = (PLFLT *) 0 ;
22680  PLINT arg5 ;
22681  Matrix temp1 ;
22682  Matrix temp2 ;
22683  Matrix temp3 ;
22684  Matrix temp4 ;
22685  octave_value_list _out;
22686  octave_value_list *_outp=&_out;
22687  octave_value _outv;
22688 
22689  try {
22690  if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
22691  SWIG_fail;
22692  }
22693  {
22694  if ( _n_dims( args(0) ) > 1 )
22695  {
22696  error( "argument must be a scalar or vector" ); SWIG_fail;
22697  }
22698  Alen = (PLINT) ( _dim( args(0), 0 ) );
22699  temp1 = args(0).matrix_value();
22700  arg1 = new PLINT[Alen];
22701  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22702  }
22703  {
22704  if ( _n_dims( args(1) ) > 1 )
22705  {
22706  error( "argument must be a scalar or vector" ); SWIG_fail;
22707  }
22708  if ( _dim( args(1), 0 ) != Alen )
22709  {
22710  error( "argument vectors must be same length" ); SWIG_fail;
22711  }
22712  temp2 = args(1).matrix_value();
22713  arg2 = new PLINT[Alen];
22714  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22715  }
22716  {
22717  if ( _n_dims( args(2) ) > 1 )
22718  {
22719  error( "argument must be a scalar or vector" ); SWIG_fail;
22720  }
22721  if ( _dim( args(2), 0 ) != Alen )
22722  {
22723  error( "argument vectors must be same length" ); SWIG_fail;
22724  }
22725  temp3 = args(2).matrix_value();
22726  arg3 = new PLINT[Alen];
22727  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22728  }
22729  {
22730  if ( _n_dims( args(3) ) > 1 )
22731  {
22732  error( "argument must be a scalar or vector" ); SWIG_fail;
22733  }
22734  if ( _dim( args(3), 0 ) != Alen )
22735  {
22736  error( "argument vectors must be same length" ); SWIG_fail;
22737  }
22738  temp4 = args(3).matrix_value();
22739  arg4 = &temp4( 0, 0 );
22740  arg5 = (PLINT) ( _dim( args(3), 0 ) );
22741  }
22742  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22743  _outv = octave_value();
22744  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22745  {
22746  delete [] arg1;
22747  }
22748  {
22749  delete [] arg2;
22750  }
22751  {
22752  delete [] arg3;
22753  }
22754  {
22755 
22756  }
22757  return _out;
22758  fail:
22759  {
22760  delete [] arg1;
22761  }
22762  {
22763  delete [] arg2;
22764  }
22765  {
22766  delete [] arg3;
22767  }
22768  {
22769 
22770  }
22771  return octave_value_list();
22772  }
22773  catch(...) {
22774  {
22775  delete [] arg1;
22776  }
22777  {
22778  delete [] arg2;
22779  }
22780  {
22781  delete [] arg3;
22782  }
22783  {
22784 
22785  }
22786  throw;
22787  }
22788 }
22789 
22790 
22792  PLBOOL arg1 ;
22793  PLINT arg2 ;
22794  PLFLT *arg3 = (PLFLT *) 0 ;
22795  PLFLT *arg4 = (PLFLT *) 0 ;
22796  PLFLT *arg5 = (PLFLT *) 0 ;
22797  PLFLT *arg6 = (PLFLT *) 0 ;
22798  PLBOOL *arg7 = (PLBOOL *) 0 ;
22799  int val1 ;
22800  int ecode1 = 0 ;
22801  Matrix temp2 ;
22802  Matrix temp4 ;
22803  Matrix temp5 ;
22804  Matrix temp6 ;
22805  Matrix temp7 ;
22806  octave_value_list _out;
22807  octave_value_list *_outp=&_out;
22808  octave_value _outv;
22809 
22810  try {
22811  if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
22812  SWIG_fail;
22813  }
22814  ecode1 = SWIG_AsVal_int(args(0), &val1);
22815  if (!SWIG_IsOK(ecode1)) {
22816  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
22817  }
22818  arg1 = static_cast< PLBOOL >(val1);
22819  {
22820  if ( _n_dims( args(1) ) > 1 )
22821  {
22822  error( "argument must be a scalar or vector" ); SWIG_fail;
22823  }
22824  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
22825  temp2 = args(1).matrix_value();
22826  arg3 = &temp2( 0, 0 );
22827  }
22828  {
22829  if ( _n_dims( args(2) ) > 1 )
22830  {
22831  error( "argument must be a scalar or vector" ); SWIG_fail;
22832  }
22833  if ( _dim( args(2), 0 ) != Alen )
22834  {
22835  error( "argument vectors must be same length" ); SWIG_fail;
22836  }
22837  temp4 = args(2).matrix_value();
22838  arg4 = &temp4( 0, 0 );
22839  }
22840  {
22841  if ( _n_dims( args(3) ) > 1 )
22842  {
22843  error( "argument must be a scalar or vector" ); SWIG_fail;
22844  }
22845  if ( _dim( args(3), 0 ) != Alen )
22846  {
22847  error( "argument vectors must be same length" ); SWIG_fail;
22848  }
22849  temp5 = args(3).matrix_value();
22850  arg5 = &temp5( 0, 0 );
22851  }
22852  {
22853  if ( _n_dims( args(4) ) > 1 )
22854  {
22855  error( "argument must be a scalar or vector" ); SWIG_fail;
22856  }
22857  if ( _dim( args(4), 0 ) != Alen )
22858  {
22859  error( "argument vectors must be same length" ); SWIG_fail;
22860  }
22861  temp6 = args(4).matrix_value();
22862  arg6 = &temp6( 0, 0 );
22863  }
22864  {
22865  if ( _n_dims( args(5) ) > 1 )
22866  {
22867  error( "argument must be a scalar or vector" ); SWIG_fail;
22868  }
22869  if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
22870  {
22871  error( "argument vector must be same length or one less" ); SWIG_fail;
22872  }
22873  temp7 = args(5).matrix_value();
22874  arg7 = new PLINT[Alen];
22875  _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
22876  }
22877  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
22878  _outv = octave_value();
22879  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22880  {
22881 
22882  }
22883  {
22884 
22885  }
22886  {
22887 
22888  }
22889  {
22890 
22891  }
22892  {
22893  delete [] arg7;
22894  }
22895  return _out;
22896  fail:
22897  {
22898 
22899  }
22900  {
22901 
22902  }
22903  {
22904 
22905  }
22906  {
22907 
22908  }
22909  {
22910  delete [] arg7;
22911  }
22912  return octave_value_list();
22913  }
22914  catch(...) {
22915  {
22916 
22917  }
22918  {
22919 
22920  }
22921  {
22922 
22923  }
22924  {
22925 
22926  }
22927  {
22928  delete [] arg7;
22929  }
22930  throw;
22931  }
22932 }
22933 
22934 
22936  PLBOOL arg1 ;
22937  PLINT arg2 ;
22938  PLFLT *arg3 = (PLFLT *) 0 ;
22939  PLFLT *arg4 = (PLFLT *) 0 ;
22940  PLFLT *arg5 = (PLFLT *) 0 ;
22941  PLFLT *arg6 = (PLFLT *) 0 ;
22942  PLFLT *arg7 = (PLFLT *) 0 ;
22943  PLBOOL *arg8 = (PLBOOL *) 0 ;
22944  int val1 ;
22945  int ecode1 = 0 ;
22946  Matrix temp2 ;
22947  Matrix temp4 ;
22948  Matrix temp5 ;
22949  Matrix temp6 ;
22950  Matrix temp7 ;
22951  Matrix temp8 ;
22952  octave_value_list _out;
22953  octave_value_list *_outp=&_out;
22954  octave_value _outv;
22955 
22956  try {
22957  if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
22958  SWIG_fail;
22959  }
22960  ecode1 = SWIG_AsVal_int(args(0), &val1);
22961  if (!SWIG_IsOK(ecode1)) {
22962  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
22963  }
22964  arg1 = static_cast< PLBOOL >(val1);
22965  {
22966  if ( _n_dims( args(1) ) > 1 )
22967  {
22968  error( "argument must be a scalar or vector" ); SWIG_fail;
22969  }
22970  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
22971  temp2 = args(1).matrix_value();
22972  arg3 = &temp2( 0, 0 );
22973  }
22974  {
22975  if ( _n_dims( args(2) ) > 1 )
22976  {
22977  error( "argument must be a scalar or vector" ); SWIG_fail;
22978  }
22979  if ( _dim( args(2), 0 ) != Alen )
22980  {
22981  error( "argument vectors must be same length" ); SWIG_fail;
22982  }
22983  temp4 = args(2).matrix_value();
22984  arg4 = &temp4( 0, 0 );
22985  }
22986  {
22987  if ( _n_dims( args(3) ) > 1 )
22988  {
22989  error( "argument must be a scalar or vector" ); SWIG_fail;
22990  }
22991  if ( _dim( args(3), 0 ) != Alen )
22992  {
22993  error( "argument vectors must be same length" ); SWIG_fail;
22994  }
22995  temp5 = args(3).matrix_value();
22996  arg5 = &temp5( 0, 0 );
22997  }
22998  {
22999  if ( _n_dims( args(4) ) > 1 )
23000  {
23001  error( "argument must be a scalar or vector" ); SWIG_fail;
23002  }
23003  if ( _dim( args(4), 0 ) != Alen )
23004  {
23005  error( "argument vectors must be same length" ); SWIG_fail;
23006  }
23007  temp6 = args(4).matrix_value();
23008  arg6 = &temp6( 0, 0 );
23009  }
23010  {
23011  if ( _n_dims( args(5) ) > 1 )
23012  {
23013  error( "argument must be a scalar or vector" ); SWIG_fail;
23014  }
23015  if ( _dim( args(5), 0 ) != Alen )
23016  {
23017  error( "argument vectors must be same length" ); SWIG_fail;
23018  }
23019  temp7 = args(5).matrix_value();
23020  arg7 = &temp7( 0, 0 );
23021  }
23022  {
23023  if ( _n_dims( args(6) ) > 1 )
23024  {
23025  error( "argument must be a scalar or vector" ); SWIG_fail;
23026  }
23027  if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
23028  {
23029  error( "argument vector must be same length or one less" ); SWIG_fail;
23030  }
23031  temp8 = args(6).matrix_value();
23032  arg8 = new PLINT[Alen];
23033  _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
23034  }
23035  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
23036  _outv = octave_value();
23037  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23038  {
23039 
23040  }
23041  {
23042 
23043  }
23044  {
23045 
23046  }
23047  {
23048 
23049  }
23050  {
23051 
23052  }
23053  {
23054  delete [] arg8;
23055  }
23056  return _out;
23057  fail:
23058  {
23059 
23060  }
23061  {
23062 
23063  }
23064  {
23065 
23066  }
23067  {
23068 
23069  }
23070  {
23071 
23072  }
23073  {
23074  delete [] arg8;
23075  }
23076  return octave_value_list();
23077  }
23078  catch(...) {
23079  {
23080 
23081  }
23082  {
23083 
23084  }
23085  {
23086 
23087  }
23088  {
23089 
23090  }
23091  {
23092 
23093  }
23094  {
23095  delete [] arg8;
23096  }
23097  throw;
23098  }
23099 }
23100 
23101 
23103  PLINT arg1 ;
23104  int val1 ;
23105  int ecode1 = 0 ;
23106  octave_value_list _out;
23107  octave_value_list *_outp=&_out;
23108  octave_value _outv;
23109 
23110  try {
23111  if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
23112  SWIG_fail;
23113  }
23114  ecode1 = SWIG_AsVal_int(args(0), &val1);
23115  if (!SWIG_IsOK(ecode1)) {
23116  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
23117  }
23118  arg1 = static_cast< PLINT >(val1);
23119  plscmap1n(arg1);
23120  _outv = octave_value();
23121  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23122  return _out;
23123  fail:
23124  return octave_value_list();
23125  }
23126  catch(...) {
23127  throw;
23128  }
23129 }
23130 
23131 
23133  PLFLT arg1 ;
23134  PLFLT arg2 ;
23135  double val1 ;
23136  int ecode1 = 0 ;
23137  double val2 ;
23138  int ecode2 = 0 ;
23139  octave_value_list _out;
23140  octave_value_list *_outp=&_out;
23141  octave_value _outv;
23142 
23143  try {
23144  if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
23145  SWIG_fail;
23146  }
23147  ecode1 = SWIG_AsVal_double(args(0), &val1);
23148  if (!SWIG_IsOK(ecode1)) {
23149  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
23150  }
23151  arg1 = static_cast< PLFLT >(val1);
23152  ecode2 = SWIG_AsVal_double(args(1), &val2);
23153  if (!SWIG_IsOK(ecode2)) {
23154  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
23155  }
23156  arg2 = static_cast< PLFLT >(val2);
23157  plscmap1_range(arg1,arg2);
23158  _outv = octave_value();
23159  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23160  return _out;
23161  fail:
23162  return octave_value_list();
23163  }
23164  catch(...) {
23165  throw;
23166  }
23167 }
23168 
23169 
23171  PLFLT *arg1 = (PLFLT *) 0 ;
23172  PLFLT *arg2 = (PLFLT *) 0 ;
23173  PLFLT temp1 ;
23174  int res1 = SWIG_TMPOBJ ;
23175  PLFLT temp2 ;
23176  int res2 = SWIG_TMPOBJ ;
23177  octave_value_list _out;
23178  octave_value_list *_outp=&_out;
23179  octave_value _outv;
23180 
23181  try {
23182  arg1 = &temp1;
23183  arg2 = &temp2;
23184  if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
23185  SWIG_fail;
23186  }
23187  plgcmap1_range(arg1,arg2);
23188  _outv = octave_value();
23189  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23190  if (SWIG_IsTmpObj(res1)) {
23191  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
23192  } else {
23193  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23194  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
23195  }
23196  if (SWIG_IsTmpObj(res2)) {
23197  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
23198  } else {
23199  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23200  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
23201  }
23202  return _out;
23203  fail:
23204  return octave_value_list();
23205  }
23206  catch(...) {
23207  throw;
23208  }
23209 }
23210 
23211 
23213  PLINT arg1 ;
23214  PLINT arg2 ;
23215  PLINT arg3 ;
23216  PLINT arg4 ;
23217  int val1 ;
23218  int ecode1 = 0 ;
23219  int val2 ;
23220  int ecode2 = 0 ;
23221  int val3 ;
23222  int ecode3 = 0 ;
23223  int val4 ;
23224  int ecode4 = 0 ;
23225  octave_value_list _out;
23226  octave_value_list *_outp=&_out;
23227  octave_value _outv;
23228 
23229  try {
23230  if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
23231  SWIG_fail;
23232  }
23233  ecode1 = SWIG_AsVal_int(args(0), &val1);
23234  if (!SWIG_IsOK(ecode1)) {
23235  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
23236  }
23237  arg1 = static_cast< PLINT >(val1);
23238  ecode2 = SWIG_AsVal_int(args(1), &val2);
23239  if (!SWIG_IsOK(ecode2)) {
23240  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
23241  }
23242  arg2 = static_cast< PLINT >(val2);
23243  ecode3 = SWIG_AsVal_int(args(2), &val3);
23244  if (!SWIG_IsOK(ecode3)) {
23245  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
23246  }
23247  arg3 = static_cast< PLINT >(val3);
23248  ecode4 = SWIG_AsVal_int(args(3), &val4);
23249  if (!SWIG_IsOK(ecode4)) {
23250  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
23251  }
23252  arg4 = static_cast< PLINT >(val4);
23253  plscol0(arg1,arg2,arg3,arg4);
23254  _outv = octave_value();
23255  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23256  return _out;
23257  fail:
23258  return octave_value_list();
23259  }
23260  catch(...) {
23261  throw;
23262  }
23263 }
23264 
23265 
23267  PLINT arg1 ;
23268  PLINT arg2 ;
23269  PLINT arg3 ;
23270  PLINT arg4 ;
23271  PLFLT arg5 ;
23272  int val1 ;
23273  int ecode1 = 0 ;
23274  int val2 ;
23275  int ecode2 = 0 ;
23276  int val3 ;
23277  int ecode3 = 0 ;
23278  int val4 ;
23279  int ecode4 = 0 ;
23280  double val5 ;
23281  int ecode5 = 0 ;
23282  octave_value_list _out;
23283  octave_value_list *_outp=&_out;
23284  octave_value _outv;
23285 
23286  try {
23287  if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
23288  SWIG_fail;
23289  }
23290  ecode1 = SWIG_AsVal_int(args(0), &val1);
23291  if (!SWIG_IsOK(ecode1)) {
23292  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
23293  }
23294  arg1 = static_cast< PLINT >(val1);
23295  ecode2 = SWIG_AsVal_int(args(1), &val2);
23296  if (!SWIG_IsOK(ecode2)) {
23297  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
23298  }
23299  arg2 = static_cast< PLINT >(val2);
23300  ecode3 = SWIG_AsVal_int(args(2), &val3);
23301  if (!SWIG_IsOK(ecode3)) {
23302  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
23303  }
23304  arg3 = static_cast< PLINT >(val3);
23305  ecode4 = SWIG_AsVal_int(args(3), &val4);
23306  if (!SWIG_IsOK(ecode4)) {
23307  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
23308  }
23309  arg4 = static_cast< PLINT >(val4);
23310  ecode5 = SWIG_AsVal_double(args(4), &val5);
23311  if (!SWIG_IsOK(ecode5)) {
23312  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
23313  }
23314  arg5 = static_cast< PLFLT >(val5);
23315  plscol0a(arg1,arg2,arg3,arg4,arg5);
23316  _outv = octave_value();
23317  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23318  return _out;
23319  fail:
23320  return octave_value_list();
23321  }
23322  catch(...) {
23323  throw;
23324  }
23325 }
23326 
23327 
23329  PLINT arg1 ;
23330  PLINT arg2 ;
23331  PLINT arg3 ;
23332  int val1 ;
23333  int ecode1 = 0 ;
23334  int val2 ;
23335  int ecode2 = 0 ;
23336  int val3 ;
23337  int ecode3 = 0 ;
23338  octave_value_list _out;
23339  octave_value_list *_outp=&_out;
23340  octave_value _outv;
23341 
23342  try {
23343  if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
23344  SWIG_fail;
23345  }
23346  ecode1 = SWIG_AsVal_int(args(0), &val1);
23347  if (!SWIG_IsOK(ecode1)) {
23348  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
23349  }
23350  arg1 = static_cast< PLINT >(val1);
23351  ecode2 = SWIG_AsVal_int(args(1), &val2);
23352  if (!SWIG_IsOK(ecode2)) {
23353  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
23354  }
23355  arg2 = static_cast< PLINT >(val2);
23356  ecode3 = SWIG_AsVal_int(args(2), &val3);
23357  if (!SWIG_IsOK(ecode3)) {
23358  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
23359  }
23360  arg3 = static_cast< PLINT >(val3);
23361  plscolbg(arg1,arg2,arg3);
23362  _outv = octave_value();
23363  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23364  return _out;
23365  fail:
23366  return octave_value_list();
23367  }
23368  catch(...) {
23369  throw;
23370  }
23371 }
23372 
23373 
23375  PLINT arg1 ;
23376  PLINT arg2 ;
23377  PLINT arg3 ;
23378  PLFLT arg4 ;
23379  int val1 ;
23380  int ecode1 = 0 ;
23381  int val2 ;
23382  int ecode2 = 0 ;
23383  int val3 ;
23384  int ecode3 = 0 ;
23385  double val4 ;
23386  int ecode4 = 0 ;
23387  octave_value_list _out;
23388  octave_value_list *_outp=&_out;
23389  octave_value _outv;
23390 
23391  try {
23392  if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
23393  SWIG_fail;
23394  }
23395  ecode1 = SWIG_AsVal_int(args(0), &val1);
23396  if (!SWIG_IsOK(ecode1)) {
23397  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
23398  }
23399  arg1 = static_cast< PLINT >(val1);
23400  ecode2 = SWIG_AsVal_int(args(1), &val2);
23401  if (!SWIG_IsOK(ecode2)) {
23402  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
23403  }
23404  arg2 = static_cast< PLINT >(val2);
23405  ecode3 = SWIG_AsVal_int(args(2), &val3);
23406  if (!SWIG_IsOK(ecode3)) {
23407  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
23408  }
23409  arg3 = static_cast< PLINT >(val3);
23410  ecode4 = SWIG_AsVal_double(args(3), &val4);
23411  if (!SWIG_IsOK(ecode4)) {
23412  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
23413  }
23414  arg4 = static_cast< PLFLT >(val4);
23415  plscolbga(arg1,arg2,arg3,arg4);
23416  _outv = octave_value();
23417  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23418  return _out;
23419  fail:
23420  return octave_value_list();
23421  }
23422  catch(...) {
23423  throw;
23424  }
23425 }
23426 
23427 
23429  PLINT arg1 ;
23430  int val1 ;
23431  int ecode1 = 0 ;
23432  octave_value_list _out;
23433  octave_value_list *_outp=&_out;
23434  octave_value _outv;
23435 
23436  try {
23437  if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
23438  SWIG_fail;
23439  }
23440  ecode1 = SWIG_AsVal_int(args(0), &val1);
23441  if (!SWIG_IsOK(ecode1)) {
23442  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
23443  }
23444  arg1 = static_cast< PLINT >(val1);
23445  plscolor(arg1);
23446  _outv = octave_value();
23447  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23448  return _out;
23449  fail:
23450  return octave_value_list();
23451  }
23452  catch(...) {
23453  throw;
23454  }
23455 }
23456 
23457 
23459  PLINT arg1 ;
23460  int val1 ;
23461  int ecode1 = 0 ;
23462  octave_value_list _out;
23463  octave_value_list *_outp=&_out;
23464  octave_value _outv;
23465 
23466  try {
23467  if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
23468  SWIG_fail;
23469  }
23470  ecode1 = SWIG_AsVal_int(args(0), &val1);
23471  if (!SWIG_IsOK(ecode1)) {
23472  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
23473  }
23474  arg1 = static_cast< PLINT >(val1);
23475  plscompression(arg1);
23476  _outv = octave_value();
23477  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23478  return _out;
23479  fail:
23480  return octave_value_list();
23481  }
23482  catch(...) {
23483  throw;
23484  }
23485 }
23486 
23487 
23489  char *arg1 = (char *) 0 ;
23490  int res1 ;
23491  char *buf1 = 0 ;
23492  int alloc1 = 0 ;
23493  octave_value_list _out;
23494  octave_value_list *_outp=&_out;
23495  octave_value _outv;
23496 
23497  try {
23498  if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
23499  SWIG_fail;
23500  }
23501  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23502  if (!SWIG_IsOK(res1)) {
23503  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
23504  }
23505  arg1 = reinterpret_cast< char * >(buf1);
23506  plsdev((char const *)arg1);
23507  _outv = octave_value();
23508  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23509  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23510  return _out;
23511  fail:
23512  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23513  return octave_value_list();
23514  }
23515  catch(...) {
23516  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23517  throw;
23518  }
23519 }
23520 
23521 
23523  PLFLT arg1 ;
23524  PLFLT arg2 ;
23525  PLFLT arg3 ;
23526  PLFLT arg4 ;
23527  double val1 ;
23528  int ecode1 = 0 ;
23529  double val2 ;
23530  int ecode2 = 0 ;
23531  double val3 ;
23532  int ecode3 = 0 ;
23533  double val4 ;
23534  int ecode4 = 0 ;
23535  octave_value_list _out;
23536  octave_value_list *_outp=&_out;
23537  octave_value _outv;
23538 
23539  try {
23540  if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
23541  SWIG_fail;
23542  }
23543  ecode1 = SWIG_AsVal_double(args(0), &val1);
23544  if (!SWIG_IsOK(ecode1)) {
23545  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
23546  }
23547  arg1 = static_cast< PLFLT >(val1);
23548  ecode2 = SWIG_AsVal_double(args(1), &val2);
23549  if (!SWIG_IsOK(ecode2)) {
23550  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
23551  }
23552  arg2 = static_cast< PLFLT >(val2);
23553  ecode3 = SWIG_AsVal_double(args(2), &val3);
23554  if (!SWIG_IsOK(ecode3)) {
23555  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
23556  }
23557  arg3 = static_cast< PLFLT >(val3);
23558  ecode4 = SWIG_AsVal_double(args(3), &val4);
23559  if (!SWIG_IsOK(ecode4)) {
23560  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
23561  }
23562  arg4 = static_cast< PLFLT >(val4);
23563  plsdidev(arg1,arg2,arg3,arg4);
23564  _outv = octave_value();
23565  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23566  return _out;
23567  fail:
23568  return octave_value_list();
23569  }
23570  catch(...) {
23571  throw;
23572  }
23573 }
23574 
23575 
23577  PLINT arg1 ;
23578  PLINT arg2 ;
23579  PLINT arg3 ;
23580  PLINT arg4 ;
23581  PLFLT arg5 ;
23582  PLFLT arg6 ;
23583  int val1 ;
23584  int ecode1 = 0 ;
23585  int val2 ;
23586  int ecode2 = 0 ;
23587  int val3 ;
23588  int ecode3 = 0 ;
23589  int val4 ;
23590  int ecode4 = 0 ;
23591  double val5 ;
23592  int ecode5 = 0 ;
23593  double val6 ;
23594  int ecode6 = 0 ;
23595  octave_value_list _out;
23596  octave_value_list *_outp=&_out;
23597  octave_value _outv;
23598 
23599  try {
23600  if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
23601  SWIG_fail;
23602  }
23603  ecode1 = SWIG_AsVal_int(args(0), &val1);
23604  if (!SWIG_IsOK(ecode1)) {
23605  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
23606  }
23607  arg1 = static_cast< PLINT >(val1);
23608  ecode2 = SWIG_AsVal_int(args(1), &val2);
23609  if (!SWIG_IsOK(ecode2)) {
23610  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
23611  }
23612  arg2 = static_cast< PLINT >(val2);
23613  ecode3 = SWIG_AsVal_int(args(2), &val3);
23614  if (!SWIG_IsOK(ecode3)) {
23615  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
23616  }
23617  arg3 = static_cast< PLINT >(val3);
23618  ecode4 = SWIG_AsVal_int(args(3), &val4);
23619  if (!SWIG_IsOK(ecode4)) {
23620  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
23621  }
23622  arg4 = static_cast< PLINT >(val4);
23623  ecode5 = SWIG_AsVal_double(args(4), &val5);
23624  if (!SWIG_IsOK(ecode5)) {
23625  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
23626  }
23627  arg5 = static_cast< PLFLT >(val5);
23628  ecode6 = SWIG_AsVal_double(args(5), &val6);
23629  if (!SWIG_IsOK(ecode6)) {
23630  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
23631  }
23632  arg6 = static_cast< PLFLT >(val6);
23633  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23634  _outv = octave_value();
23635  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23636  return _out;
23637  fail:
23638  return octave_value_list();
23639  }
23640  catch(...) {
23641  throw;
23642  }
23643 }
23644 
23645 
23647  PLFLT arg1 ;
23648  double val1 ;
23649  int ecode1 = 0 ;
23650  octave_value_list _out;
23651  octave_value_list *_outp=&_out;
23652  octave_value _outv;
23653 
23654  try {
23655  if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
23656  SWIG_fail;
23657  }
23658  ecode1 = SWIG_AsVal_double(args(0), &val1);
23659  if (!SWIG_IsOK(ecode1)) {
23660  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
23661  }
23662  arg1 = static_cast< PLFLT >(val1);
23663  plsdiori(arg1);
23664  _outv = octave_value();
23665  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23666  return _out;
23667  fail:
23668  return octave_value_list();
23669  }
23670  catch(...) {
23671  throw;
23672  }
23673 }
23674 
23675 
23677  PLFLT arg1 ;
23678  PLFLT arg2 ;
23679  PLFLT arg3 ;
23680  PLFLT arg4 ;
23681  double val1 ;
23682  int ecode1 = 0 ;
23683  double val2 ;
23684  int ecode2 = 0 ;
23685  double val3 ;
23686  int ecode3 = 0 ;
23687  double val4 ;
23688  int ecode4 = 0 ;
23689  octave_value_list _out;
23690  octave_value_list *_outp=&_out;
23691  octave_value _outv;
23692 
23693  try {
23694  if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
23695  SWIG_fail;
23696  }
23697  ecode1 = SWIG_AsVal_double(args(0), &val1);
23698  if (!SWIG_IsOK(ecode1)) {
23699  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
23700  }
23701  arg1 = static_cast< PLFLT >(val1);
23702  ecode2 = SWIG_AsVal_double(args(1), &val2);
23703  if (!SWIG_IsOK(ecode2)) {
23704  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
23705  }
23706  arg2 = static_cast< PLFLT >(val2);
23707  ecode3 = SWIG_AsVal_double(args(2), &val3);
23708  if (!SWIG_IsOK(ecode3)) {
23709  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
23710  }
23711  arg3 = static_cast< PLFLT >(val3);
23712  ecode4 = SWIG_AsVal_double(args(3), &val4);
23713  if (!SWIG_IsOK(ecode4)) {
23714  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
23715  }
23716  arg4 = static_cast< PLFLT >(val4);
23717  plsdiplt(arg1,arg2,arg3,arg4);
23718  _outv = octave_value();
23719  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23720  return _out;
23721  fail:
23722  return octave_value_list();
23723  }
23724  catch(...) {
23725  throw;
23726  }
23727 }
23728 
23729 
23731  PLFLT arg1 ;
23732  PLFLT arg2 ;
23733  PLFLT arg3 ;
23734  PLFLT arg4 ;
23735  double val1 ;
23736  int ecode1 = 0 ;
23737  double val2 ;
23738  int ecode2 = 0 ;
23739  double val3 ;
23740  int ecode3 = 0 ;
23741  double val4 ;
23742  int ecode4 = 0 ;
23743  octave_value_list _out;
23744  octave_value_list *_outp=&_out;
23745  octave_value _outv;
23746 
23747  try {
23748  if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
23749  SWIG_fail;
23750  }
23751  ecode1 = SWIG_AsVal_double(args(0), &val1);
23752  if (!SWIG_IsOK(ecode1)) {
23753  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
23754  }
23755  arg1 = static_cast< PLFLT >(val1);
23756  ecode2 = SWIG_AsVal_double(args(1), &val2);
23757  if (!SWIG_IsOK(ecode2)) {
23758  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
23759  }
23760  arg2 = static_cast< PLFLT >(val2);
23761  ecode3 = SWIG_AsVal_double(args(2), &val3);
23762  if (!SWIG_IsOK(ecode3)) {
23763  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
23764  }
23765  arg3 = static_cast< PLFLT >(val3);
23766  ecode4 = SWIG_AsVal_double(args(3), &val4);
23767  if (!SWIG_IsOK(ecode4)) {
23768  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
23769  }
23770  arg4 = static_cast< PLFLT >(val4);
23771  plsdiplz(arg1,arg2,arg3,arg4);
23772  _outv = octave_value();
23773  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23774  return _out;
23775  fail:
23776  return octave_value_list();
23777  }
23778  catch(...) {
23779  throw;
23780  }
23781 }
23782 
23783 
23785  unsigned int arg1 ;
23786  unsigned int val1 ;
23787  int ecode1 = 0 ;
23788  octave_value_list _out;
23789  octave_value_list *_outp=&_out;
23790  octave_value _outv;
23791 
23792  try {
23793  if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
23794  SWIG_fail;
23795  }
23796  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
23797  if (!SWIG_IsOK(ecode1)) {
23798  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
23799  }
23800  arg1 = static_cast< unsigned int >(val1);
23801  plseed(arg1);
23802  _outv = octave_value();
23803  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23804  return _out;
23805  fail:
23806  return octave_value_list();
23807  }
23808  catch(...) {
23809  throw;
23810  }
23811 }
23812 
23813 
23815  char arg1 ;
23816  char val1 ;
23817  int ecode1 = 0 ;
23818  octave_value_list _out;
23819  octave_value_list *_outp=&_out;
23820  octave_value _outv;
23821 
23822  try {
23823  if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
23824  SWIG_fail;
23825  }
23826  ecode1 = SWIG_AsVal_char(args(0), &val1);
23827  if (!SWIG_IsOK(ecode1)) {
23828  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
23829  }
23830  arg1 = static_cast< char >(val1);
23831  plsesc(arg1);
23832  _outv = octave_value();
23833  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23834  return _out;
23835  fail:
23836  return octave_value_list();
23837  }
23838  catch(...) {
23839  throw;
23840  }
23841 }
23842 
23843 
23844 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
23845  char *arg1 = (char *) 0 ;
23846  char *arg2 = (char *) 0 ;
23847  int res1 ;
23848  char *buf1 = 0 ;
23849  int alloc1 = 0 ;
23850  int res2 ;
23851  char *buf2 = 0 ;
23852  int alloc2 = 0 ;
23853  octave_value_list _out;
23854  octave_value_list *_outp=&_out;
23855  octave_value _outv;
23856  PLINT result;
23857 
23858  try {
23859  if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
23860  SWIG_fail;
23861  }
23862  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23863  if (!SWIG_IsOK(res1)) {
23864  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
23865  }
23866  arg1 = reinterpret_cast< char * >(buf1);
23867  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
23868  if (!SWIG_IsOK(res2)) {
23869  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
23870  }
23871  arg2 = reinterpret_cast< char * >(buf2);
23872  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
23873  _outv = SWIG_From_int(static_cast< int >(result));
23874  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23875  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23876  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23877  return _out;
23878  fail:
23879  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23880  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23881  return octave_value_list();
23882  }
23883  catch(...) {
23884  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23885  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23886  throw;
23887  }
23888 }
23889 
23890 
23892  PLINT arg1 ;
23893  PLINT arg2 ;
23894  PLINT arg3 ;
23895  int val1 ;
23896  int ecode1 = 0 ;
23897  int val2 ;
23898  int ecode2 = 0 ;
23899  int val3 ;
23900  int ecode3 = 0 ;
23901  octave_value_list _out;
23902  octave_value_list *_outp=&_out;
23903  octave_value _outv;
23904 
23905  try {
23906  if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
23907  SWIG_fail;
23908  }
23909  ecode1 = SWIG_AsVal_int(args(0), &val1);
23910  if (!SWIG_IsOK(ecode1)) {
23911  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
23912  }
23913  arg1 = static_cast< PLINT >(val1);
23914  ecode2 = SWIG_AsVal_int(args(1), &val2);
23915  if (!SWIG_IsOK(ecode2)) {
23916  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
23917  }
23918  arg2 = static_cast< PLINT >(val2);
23919  ecode3 = SWIG_AsVal_int(args(2), &val3);
23920  if (!SWIG_IsOK(ecode3)) {
23921  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
23922  }
23923  arg3 = static_cast< PLINT >(val3);
23924  plsfam(arg1,arg2,arg3);
23925  _outv = octave_value();
23926  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23927  return _out;
23928  fail:
23929  return octave_value_list();
23930  }
23931  catch(...) {
23932  throw;
23933  }
23934 }
23935 
23936 
23938  PLUNICODE arg1 ;
23939  unsigned int val1 ;
23940  int ecode1 = 0 ;
23941  octave_value_list _out;
23942  octave_value_list *_outp=&_out;
23943  octave_value _outv;
23944 
23945  try {
23946  if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
23947  SWIG_fail;
23948  }
23949  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
23950  if (!SWIG_IsOK(ecode1)) {
23951  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
23952  }
23953  arg1 = static_cast< PLUNICODE >(val1);
23954  plsfci(arg1);
23955  _outv = octave_value();
23956  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23957  return _out;
23958  fail:
23959  return octave_value_list();
23960  }
23961  catch(...) {
23962  throw;
23963  }
23964 }
23965 
23966 
23968  char *arg1 = (char *) 0 ;
23969  int res1 ;
23970  char *buf1 = 0 ;
23971  int alloc1 = 0 ;
23972  octave_value_list _out;
23973  octave_value_list *_outp=&_out;
23974  octave_value _outv;
23975 
23976  try {
23977  if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
23978  SWIG_fail;
23979  }
23980  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23981  if (!SWIG_IsOK(res1)) {
23982  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
23983  }
23984  arg1 = reinterpret_cast< char * >(buf1);
23985  plsfnam((char const *)arg1);
23986  _outv = octave_value();
23987  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23988  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23989  return _out;
23990  fail:
23991  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23992  return octave_value_list();
23993  }
23994  catch(...) {
23995  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23996  throw;
23997  }
23998 }
23999 
24000 
24002  PLINT arg1 ;
24003  PLINT arg2 ;
24004  PLINT arg3 ;
24005  int val1 ;
24006  int ecode1 = 0 ;
24007  int val2 ;
24008  int ecode2 = 0 ;
24009  int val3 ;
24010  int ecode3 = 0 ;
24011  octave_value_list _out;
24012  octave_value_list *_outp=&_out;
24013  octave_value _outv;
24014 
24015  try {
24016  if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
24017  SWIG_fail;
24018  }
24019  ecode1 = SWIG_AsVal_int(args(0), &val1);
24020  if (!SWIG_IsOK(ecode1)) {
24021  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
24022  }
24023  arg1 = static_cast< PLINT >(val1);
24024  ecode2 = SWIG_AsVal_int(args(1), &val2);
24025  if (!SWIG_IsOK(ecode2)) {
24026  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
24027  }
24028  arg2 = static_cast< PLINT >(val2);
24029  ecode3 = SWIG_AsVal_int(args(2), &val3);
24030  if (!SWIG_IsOK(ecode3)) {
24031  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
24032  }
24033  arg3 = static_cast< PLINT >(val3);
24034  plsfont(arg1,arg2,arg3);
24035  _outv = octave_value();
24036  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24037  return _out;
24038  fail:
24039  return octave_value_list();
24040  }
24041  catch(...) {
24042  throw;
24043  }
24044 }
24045 
24046 
24048  label_func arg1 = (label_func) 0 ;
24049  PLPointer arg2 = (PLPointer) 0 ;
24050  int res2 ;
24051  octave_value_list _out;
24052  octave_value_list *_outp=&_out;
24053  octave_value _outv;
24054 
24055  try {
24056  if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
24057  SWIG_fail;
24058  }
24059  {
24060  octave_value obj = args(0);
24061 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24062  if ( !obj.isempty() )
24063 #else
24064  if ( !obj.is_empty() )
24065 #endif
24066  {
24067  if ( obj.is_function_handle() || obj.is_inline_function() )
24068  {
24069  fcnLabelFunc = obj.function_value();
24070  }
24071  else if ( obj.is_string() )
24072  {
24073  nameLabelFunc = obj.string_value();
24074  fcnLabelFunc = NULL;
24075  }
24076  arg1 = labelfunc_octave;
24077  }
24078  else
24079  {
24080  arg1 = NULL;
24081  }
24082  }
24083  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24084  if (!SWIG_IsOK(res2)) {
24085  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
24086  }
24087  plslabelfunc(arg1,arg2);
24088  _outv = octave_value();
24089  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24090  return _out;
24091  fail:
24092  return octave_value_list();
24093  }
24094  catch(...) {
24095  throw;
24096  }
24097 }
24098 
24099 
24101  PLFLT arg1 ;
24102  PLFLT arg2 ;
24103  double val1 ;
24104  int ecode1 = 0 ;
24105  double val2 ;
24106  int ecode2 = 0 ;
24107  octave_value_list _out;
24108  octave_value_list *_outp=&_out;
24109  octave_value _outv;
24110 
24111  try {
24112  if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
24113  SWIG_fail;
24114  }
24115  ecode1 = SWIG_AsVal_double(args(0), &val1);
24116  if (!SWIG_IsOK(ecode1)) {
24117  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
24118  }
24119  arg1 = static_cast< PLFLT >(val1);
24120  ecode2 = SWIG_AsVal_double(args(1), &val2);
24121  if (!SWIG_IsOK(ecode2)) {
24122  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
24123  }
24124  arg2 = static_cast< PLFLT >(val2);
24125  plsmaj(arg1,arg2);
24126  _outv = octave_value();
24127  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24128  return _out;
24129  fail:
24130  return octave_value_list();
24131  }
24132  catch(...) {
24133  throw;
24134  }
24135 }
24136 
24137 
24139  PLFLT arg1 ;
24140  PLFLT arg2 ;
24141  double val1 ;
24142  int ecode1 = 0 ;
24143  double val2 ;
24144  int ecode2 = 0 ;
24145  octave_value_list _out;
24146  octave_value_list *_outp=&_out;
24147  octave_value _outv;
24148 
24149  try {
24150  if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
24151  SWIG_fail;
24152  }
24153  ecode1 = SWIG_AsVal_double(args(0), &val1);
24154  if (!SWIG_IsOK(ecode1)) {
24155  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
24156  }
24157  arg1 = static_cast< PLFLT >(val1);
24158  ecode2 = SWIG_AsVal_double(args(1), &val2);
24159  if (!SWIG_IsOK(ecode2)) {
24160  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
24161  }
24162  arg2 = static_cast< PLFLT >(val2);
24163  plsmin(arg1,arg2);
24164  _outv = octave_value();
24165  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24166  return _out;
24167  fail:
24168  return octave_value_list();
24169  }
24170  catch(...) {
24171  throw;
24172  }
24173 }
24174 
24175 
24177  PLINT arg1 ;
24178  int val1 ;
24179  int ecode1 = 0 ;
24180  octave_value_list _out;
24181  octave_value_list *_outp=&_out;
24182  octave_value _outv;
24183 
24184  try {
24185  if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
24186  SWIG_fail;
24187  }
24188  ecode1 = SWIG_AsVal_int(args(0), &val1);
24189  if (!SWIG_IsOK(ecode1)) {
24190  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
24191  }
24192  arg1 = static_cast< PLINT >(val1);
24193  plsori(arg1);
24194  _outv = octave_value();
24195  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24196  return _out;
24197  fail:
24198  return octave_value_list();
24199  }
24200  catch(...) {
24201  throw;
24202  }
24203 }
24204 
24205 
24207  PLFLT arg1 ;
24208  PLFLT arg2 ;
24209  PLINT arg3 ;
24210  PLINT arg4 ;
24211  PLINT arg5 ;
24212  PLINT arg6 ;
24213  double val1 ;
24214  int ecode1 = 0 ;
24215  double val2 ;
24216  int ecode2 = 0 ;
24217  int val3 ;
24218  int ecode3 = 0 ;
24219  int val4 ;
24220  int ecode4 = 0 ;
24221  int val5 ;
24222  int ecode5 = 0 ;
24223  int val6 ;
24224  int ecode6 = 0 ;
24225  octave_value_list _out;
24226  octave_value_list *_outp=&_out;
24227  octave_value _outv;
24228 
24229  try {
24230  if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
24231  SWIG_fail;
24232  }
24233  ecode1 = SWIG_AsVal_double(args(0), &val1);
24234  if (!SWIG_IsOK(ecode1)) {
24235  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
24236  }
24237  arg1 = static_cast< PLFLT >(val1);
24238  ecode2 = SWIG_AsVal_double(args(1), &val2);
24239  if (!SWIG_IsOK(ecode2)) {
24240  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
24241  }
24242  arg2 = static_cast< PLFLT >(val2);
24243  ecode3 = SWIG_AsVal_int(args(2), &val3);
24244  if (!SWIG_IsOK(ecode3)) {
24245  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
24246  }
24247  arg3 = static_cast< PLINT >(val3);
24248  ecode4 = SWIG_AsVal_int(args(3), &val4);
24249  if (!SWIG_IsOK(ecode4)) {
24250  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
24251  }
24252  arg4 = static_cast< PLINT >(val4);
24253  ecode5 = SWIG_AsVal_int(args(4), &val5);
24254  if (!SWIG_IsOK(ecode5)) {
24255  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
24256  }
24257  arg5 = static_cast< PLINT >(val5);
24258  ecode6 = SWIG_AsVal_int(args(5), &val6);
24259  if (!SWIG_IsOK(ecode6)) {
24260  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
24261  }
24262  arg6 = static_cast< PLINT >(val6);
24263  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24264  _outv = octave_value();
24265  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24266  return _out;
24267  fail:
24268  return octave_value_list();
24269  }
24270  catch(...) {
24271  throw;
24272  }
24273 }
24274 
24275 
24277  char *arg1 = (char *) 0 ;
24278  int res1 ;
24279  char *buf1 = 0 ;
24280  int alloc1 = 0 ;
24281  octave_value_list _out;
24282  octave_value_list *_outp=&_out;
24283  octave_value _outv;
24284 
24285  try {
24286  if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
24287  SWIG_fail;
24288  }
24289  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24290  if (!SWIG_IsOK(res1)) {
24291  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
24292  }
24293  arg1 = reinterpret_cast< char * >(buf1);
24294  plspal0((char const *)arg1);
24295  _outv = octave_value();
24296  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24297  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24298  return _out;
24299  fail:
24300  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24301  return octave_value_list();
24302  }
24303  catch(...) {
24304  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24305  throw;
24306  }
24307 }
24308 
24309 
24311  char *arg1 = (char *) 0 ;
24312  PLBOOL arg2 ;
24313  int res1 ;
24314  char *buf1 = 0 ;
24315  int alloc1 = 0 ;
24316  int val2 ;
24317  int ecode2 = 0 ;
24318  octave_value_list _out;
24319  octave_value_list *_outp=&_out;
24320  octave_value _outv;
24321 
24322  try {
24323  if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
24324  SWIG_fail;
24325  }
24326  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24327  if (!SWIG_IsOK(res1)) {
24328  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
24329  }
24330  arg1 = reinterpret_cast< char * >(buf1);
24331  ecode2 = SWIG_AsVal_int(args(1), &val2);
24332  if (!SWIG_IsOK(ecode2)) {
24333  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
24334  }
24335  arg2 = static_cast< PLBOOL >(val2);
24336  plspal1((char const *)arg1,arg2);
24337  _outv = octave_value();
24338  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24339  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24340  return _out;
24341  fail:
24342  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24343  return octave_value_list();
24344  }
24345  catch(...) {
24346  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24347  throw;
24348  }
24349 }
24350 
24351 
24353  PLBOOL arg1 ;
24354  int val1 ;
24355  int ecode1 = 0 ;
24356  octave_value_list _out;
24357  octave_value_list *_outp=&_out;
24358  octave_value _outv;
24359 
24360  try {
24361  if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
24362  SWIG_fail;
24363  }
24364  ecode1 = SWIG_AsVal_int(args(0), &val1);
24365  if (!SWIG_IsOK(ecode1)) {
24366  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
24367  }
24368  arg1 = static_cast< PLBOOL >(val1);
24369  plspause(arg1);
24370  _outv = octave_value();
24371  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24372  return _out;
24373  fail:
24374  return octave_value_list();
24375  }
24376  catch(...) {
24377  throw;
24378  }
24379 }
24380 
24381 
24383  PLINT arg1 ;
24384  int val1 ;
24385  int ecode1 = 0 ;
24386  octave_value_list _out;
24387  octave_value_list *_outp=&_out;
24388  octave_value _outv;
24389 
24390  try {
24391  if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
24392  SWIG_fail;
24393  }
24394  ecode1 = SWIG_AsVal_int(args(0), &val1);
24395  if (!SWIG_IsOK(ecode1)) {
24396  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
24397  }
24398  arg1 = static_cast< PLINT >(val1);
24399  plsstrm(arg1);
24400  _outv = octave_value();
24401  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24402  return _out;
24403  fail:
24404  return octave_value_list();
24405  }
24406  catch(...) {
24407  throw;
24408  }
24409 }
24410 
24411 
24413  PLINT arg1 ;
24414  PLINT arg2 ;
24415  int val1 ;
24416  int ecode1 = 0 ;
24417  int val2 ;
24418  int ecode2 = 0 ;
24419  octave_value_list _out;
24420  octave_value_list *_outp=&_out;
24421  octave_value _outv;
24422 
24423  try {
24424  if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
24425  SWIG_fail;
24426  }
24427  ecode1 = SWIG_AsVal_int(args(0), &val1);
24428  if (!SWIG_IsOK(ecode1)) {
24429  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
24430  }
24431  arg1 = static_cast< PLINT >(val1);
24432  ecode2 = SWIG_AsVal_int(args(1), &val2);
24433  if (!SWIG_IsOK(ecode2)) {
24434  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
24435  }
24436  arg2 = static_cast< PLINT >(val2);
24437  plssub(arg1,arg2);
24438  _outv = octave_value();
24439  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24440  return _out;
24441  fail:
24442  return octave_value_list();
24443  }
24444  catch(...) {
24445  throw;
24446  }
24447 }
24448 
24449 
24451  PLFLT arg1 ;
24452  PLFLT arg2 ;
24453  double val1 ;
24454  int ecode1 = 0 ;
24455  double val2 ;
24456  int ecode2 = 0 ;
24457  octave_value_list _out;
24458  octave_value_list *_outp=&_out;
24459  octave_value _outv;
24460 
24461  try {
24462  if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
24463  SWIG_fail;
24464  }
24465  ecode1 = SWIG_AsVal_double(args(0), &val1);
24466  if (!SWIG_IsOK(ecode1)) {
24467  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
24468  }
24469  arg1 = static_cast< PLFLT >(val1);
24470  ecode2 = SWIG_AsVal_double(args(1), &val2);
24471  if (!SWIG_IsOK(ecode2)) {
24472  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
24473  }
24474  arg2 = static_cast< PLFLT >(val2);
24475  plssym(arg1,arg2);
24476  _outv = octave_value();
24477  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24478  return _out;
24479  fail:
24480  return octave_value_list();
24481  }
24482  catch(...) {
24483  throw;
24484  }
24485 }
24486 
24487 
24489  PLINT arg1 ;
24490  PLINT arg2 ;
24491  int val1 ;
24492  int ecode1 = 0 ;
24493  int val2 ;
24494  int ecode2 = 0 ;
24495  octave_value_list _out;
24496  octave_value_list *_outp=&_out;
24497  octave_value _outv;
24498 
24499  try {
24500  if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
24501  SWIG_fail;
24502  }
24503  ecode1 = SWIG_AsVal_int(args(0), &val1);
24504  if (!SWIG_IsOK(ecode1)) {
24505  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
24506  }
24507  arg1 = static_cast< PLINT >(val1);
24508  ecode2 = SWIG_AsVal_int(args(1), &val2);
24509  if (!SWIG_IsOK(ecode2)) {
24510  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
24511  }
24512  arg2 = static_cast< PLINT >(val2);
24513  plstar(arg1,arg2);
24514  _outv = octave_value();
24515  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24516  return _out;
24517  fail:
24518  return octave_value_list();
24519  }
24520  catch(...) {
24521  throw;
24522  }
24523 }
24524 
24525 
24527  char *arg1 = (char *) 0 ;
24528  PLINT arg2 ;
24529  PLINT arg3 ;
24530  int res1 ;
24531  char *buf1 = 0 ;
24532  int alloc1 = 0 ;
24533  int val2 ;
24534  int ecode2 = 0 ;
24535  int val3 ;
24536  int ecode3 = 0 ;
24537  octave_value_list _out;
24538  octave_value_list *_outp=&_out;
24539  octave_value _outv;
24540 
24541  try {
24542  if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
24543  SWIG_fail;
24544  }
24545  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24546  if (!SWIG_IsOK(res1)) {
24547  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
24548  }
24549  arg1 = reinterpret_cast< char * >(buf1);
24550  ecode2 = SWIG_AsVal_int(args(1), &val2);
24551  if (!SWIG_IsOK(ecode2)) {
24552  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
24553  }
24554  arg2 = static_cast< PLINT >(val2);
24555  ecode3 = SWIG_AsVal_int(args(2), &val3);
24556  if (!SWIG_IsOK(ecode3)) {
24557  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
24558  }
24559  arg3 = static_cast< PLINT >(val3);
24560  plstart((char const *)arg1,arg2,arg3);
24561  _outv = octave_value();
24562  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24563  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24564  return _out;
24565  fail:
24566  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24567  return octave_value_list();
24568  }
24569  catch(...) {
24570  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24571  throw;
24572  }
24573 }
24574 
24575 
24577  ct_func arg1 = (ct_func) 0 ;
24578  PLPointer arg2 = (PLPointer) 0 ;
24579  int res2 ;
24580  octave_value_list _out;
24581  octave_value_list *_outp=&_out;
24582  octave_value _outv;
24583 
24584  try {
24585  if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
24586  SWIG_fail;
24587  }
24588  {
24589  octave_value obj = args(0);
24590 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24591  if ( !obj.isempty() )
24592 #else
24593  if ( !obj.is_empty() )
24594 #endif
24595  {
24596  if ( obj.is_function_handle() || obj.is_inline_function() )
24597  {
24598  fcnCoordTrans = obj.function_value();
24599  }
24600  else if ( obj.is_string() )
24601  {
24602  nameCoordTrans = obj.string_value();
24603  fcnCoordTrans = NULL;
24604  }
24605  arg1 = ct_octave;
24606  }
24607  else
24608  {
24609  arg1 = NULL;
24610  }
24611  }
24612  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24613  if (!SWIG_IsOK(res2)) {
24614  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
24615  }
24616  plstransform(arg1,arg2);
24617  _outv = octave_value();
24618  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24619  return _out;
24620  fail:
24621  return octave_value_list();
24622  }
24623  catch(...) {
24624  throw;
24625  }
24626 }
24627 
24628 
24630  PLINT arg1 ;
24631  PLFLT *arg2 = (PLFLT *) 0 ;
24632  PLFLT *arg3 = (PLFLT *) 0 ;
24633  char *arg4 = (char *) 0 ;
24634  Matrix temp1 ;
24635  Matrix temp3 ;
24636  int res4 ;
24637  char *buf4 = 0 ;
24638  int alloc4 = 0 ;
24639  octave_value_list _out;
24640  octave_value_list *_outp=&_out;
24641  octave_value _outv;
24642 
24643  try {
24644  if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
24645  SWIG_fail;
24646  }
24647  {
24648  if ( _n_dims( args(0) ) > 1 )
24649  {
24650  error( "argument must be a scalar or vector" ); SWIG_fail;
24651  }
24652  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24653  temp1 = args(0).matrix_value();
24654  arg2 = &temp1( 0, 0 );
24655  }
24656  {
24657  if ( _n_dims( args(1) ) > 1 )
24658  {
24659  error( "argument must be a scalar or vector" ); SWIG_fail;
24660  }
24661  if ( _dim( args(1), 0 ) != Alen )
24662  {
24663  error( "argument vectors must be same length" ); SWIG_fail;
24664  }
24665  temp3 = args(1).matrix_value();
24666  arg3 = &temp3( 0, 0 );
24667  }
24668  res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
24669  if (!SWIG_IsOK(res4)) {
24670  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
24671  }
24672  arg4 = reinterpret_cast< char * >(buf4);
24673  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
24674  _outv = octave_value();
24675  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24676  {
24677 
24678  }
24679  {
24680 
24681  }
24682  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24683  return _out;
24684  fail:
24685  {
24686 
24687  }
24688  {
24689 
24690  }
24691  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24692  return octave_value_list();
24693  }
24694  catch(...) {
24695  {
24696 
24697  }
24698  {
24699 
24700  }
24701  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24702  throw;
24703  }
24704 }
24705 
24706 
24708  PLINT arg1 ;
24709  PLFLT *arg2 = (PLFLT *) 0 ;
24710  PLFLT *arg3 = (PLFLT *) 0 ;
24711  PLFLT *arg4 = (PLFLT *) 0 ;
24712  char *arg5 = (char *) 0 ;
24713  Matrix temp1 ;
24714  Matrix temp3 ;
24715  Matrix temp4 ;
24716  int res5 ;
24717  char *buf5 = 0 ;
24718  int alloc5 = 0 ;
24719  octave_value_list _out;
24720  octave_value_list *_outp=&_out;
24721  octave_value _outv;
24722 
24723  try {
24724  if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
24725  SWIG_fail;
24726  }
24727  {
24728  if ( _n_dims( args(0) ) > 1 )
24729  {
24730  error( "argument must be a scalar or vector" ); SWIG_fail;
24731  }
24732  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24733  temp1 = args(0).matrix_value();
24734  arg2 = &temp1( 0, 0 );
24735  }
24736  {
24737  if ( _n_dims( args(1) ) > 1 )
24738  {
24739  error( "argument must be a scalar or vector" ); SWIG_fail;
24740  }
24741  if ( _dim( args(1), 0 ) != Alen )
24742  {
24743  error( "argument vectors must be same length" ); SWIG_fail;
24744  }
24745  temp3 = args(1).matrix_value();
24746  arg3 = &temp3( 0, 0 );
24747  }
24748  {
24749  if ( _n_dims( args(2) ) > 1 )
24750  {
24751  error( "argument must be a scalar or vector" ); SWIG_fail;
24752  }
24753  if ( _dim( args(2), 0 ) != Alen )
24754  {
24755  error( "argument vectors must be same length" ); SWIG_fail;
24756  }
24757  temp4 = args(2).matrix_value();
24758  arg4 = &temp4( 0, 0 );
24759  }
24760  res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
24761  if (!SWIG_IsOK(res5)) {
24762  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
24763  }
24764  arg5 = reinterpret_cast< char * >(buf5);
24765  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
24766  _outv = octave_value();
24767  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24768  {
24769 
24770  }
24771  {
24772 
24773  }
24774  {
24775 
24776  }
24777  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24778  return _out;
24779  fail:
24780  {
24781 
24782  }
24783  {
24784 
24785  }
24786  {
24787 
24788  }
24789  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24790  return octave_value_list();
24791  }
24792  catch(...) {
24793  {
24794 
24795  }
24796  {
24797 
24798  }
24799  {
24800 
24801  }
24802  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24803  throw;
24804  }
24805 }
24806 
24807 
24809  PLINT arg1 ;
24810  PLINT arg2 ;
24811  PLFLT arg3 ;
24812  PLFLT arg4 ;
24813  int val1 ;
24814  int ecode1 = 0 ;
24815  int val2 ;
24816  int ecode2 = 0 ;
24817  double val3 ;
24818  int ecode3 = 0 ;
24819  double val4 ;
24820  int ecode4 = 0 ;
24821  octave_value_list _out;
24822  octave_value_list *_outp=&_out;
24823  octave_value _outv;
24824 
24825  try {
24826  if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
24827  SWIG_fail;
24828  }
24829  ecode1 = SWIG_AsVal_int(args(0), &val1);
24830  if (!SWIG_IsOK(ecode1)) {
24831  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
24832  }
24833  arg1 = static_cast< PLINT >(val1);
24834  ecode2 = SWIG_AsVal_int(args(1), &val2);
24835  if (!SWIG_IsOK(ecode2)) {
24836  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
24837  }
24838  arg2 = static_cast< PLINT >(val2);
24839  ecode3 = SWIG_AsVal_double(args(2), &val3);
24840  if (!SWIG_IsOK(ecode3)) {
24841  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
24842  }
24843  arg3 = static_cast< PLFLT >(val3);
24844  ecode4 = SWIG_AsVal_double(args(3), &val4);
24845  if (!SWIG_IsOK(ecode4)) {
24846  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
24847  }
24848  arg4 = static_cast< PLFLT >(val4);
24849  plstripa(arg1,arg2,arg3,arg4);
24850  _outv = octave_value();
24851  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24852  return _out;
24853  fail:
24854  return octave_value_list();
24855  }
24856  catch(...) {
24857  throw;
24858  }
24859 }
24860 
24861 
24863  PLINT arg1 ;
24864  int val1 ;
24865  int ecode1 = 0 ;
24866  octave_value_list _out;
24867  octave_value_list *_outp=&_out;
24868  octave_value _outv;
24869 
24870  try {
24871  if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
24872  SWIG_fail;
24873  }
24874  ecode1 = SWIG_AsVal_int(args(0), &val1);
24875  if (!SWIG_IsOK(ecode1)) {
24876  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
24877  }
24878  arg1 = static_cast< PLINT >(val1);
24879  plstripd(arg1);
24880  _outv = octave_value();
24881  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24882  return _out;
24883  fail:
24884  return octave_value_list();
24885  }
24886  catch(...) {
24887  throw;
24888  }
24889 }
24890 
24891 
24893  PLINT arg1 ;
24894  PLINT *arg2 = (PLINT *) 0 ;
24895  PLINT *arg3 = (PLINT *) 0 ;
24896  Matrix temp1 ;
24897  Matrix temp3 ;
24898  octave_value_list _out;
24899  octave_value_list *_outp=&_out;
24900  octave_value _outv;
24901 
24902  try {
24903  if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
24904  SWIG_fail;
24905  }
24906  {
24907  if ( _n_dims( args(0) ) > 1 )
24908  {
24909  error( "argument must be a scalar or vector" ); SWIG_fail;
24910  }
24911  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24912  arg2 = new PLINT[Alen];
24913  temp1 = args(0).matrix_value();
24914  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
24915  }
24916  {
24917  if ( _n_dims( args(1) ) > 1 )
24918  {
24919  error( "argument must be a scalar or vector" ); SWIG_fail;
24920  }
24921  if ( _dim( args(1), 0 ) != Alen )
24922  {
24923  error( "argument vectors must be same length" ); SWIG_fail;
24924  }
24925  temp3 = args(1).matrix_value();
24926  arg3 = new PLINT[Alen];
24927  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
24928  }
24929  plstyl(arg1,(int const *)arg2,(int const *)arg3);
24930  _outv = octave_value();
24931  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24932  {
24933  delete [] arg2;
24934  }
24935  {
24936  delete [] arg3;
24937  }
24938  return _out;
24939  fail:
24940  {
24941  delete [] arg2;
24942  }
24943  {
24944  delete [] arg3;
24945  }
24946  return octave_value_list();
24947  }
24948  catch(...) {
24949  {
24950  delete [] arg2;
24951  }
24952  {
24953  delete [] arg3;
24954  }
24955  throw;
24956  }
24957 }
24958 
24959 
24961  PLFLT *arg1 = (PLFLT *) 0 ;
24962  PLFLT *arg2 = (PLFLT *) 0 ;
24963  PLINT arg3 ;
24964  PLBOOL arg4 ;
24965  Matrix temp1 ;
24966  Matrix temp2 ;
24967  int val4 ;
24968  int ecode4 = 0 ;
24969  octave_value_list _out;
24970  octave_value_list *_outp=&_out;
24971  octave_value _outv;
24972 
24973  try {
24974  if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
24975  SWIG_fail;
24976  }
24977  {
24978  if ( _n_dims( args(0) ) > 1 )
24979  {
24980  error( "argument must be a scalar or vector" ); SWIG_fail;
24981  }
24982 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24983  if ( !args(0).isempty() )
24984 #else
24985  if ( !args(0).is_empty() )
24986 #endif
24987  {
24988  Alen = (PLINT) ( _dim( args(0), 0 ) );
24989  temp1 = args(0).matrix_value();
24990  arg1 = &temp1( 0, 0 );
24991  }
24992  else
24993  {
24994  arg1 = NULL;
24995  Alen = 0;
24996  }
24997  }
24998  {
24999  if ( _n_dims( args(1) ) > 1 )
25000  {
25001  error( "argument must be a scalar or vector" ); SWIG_fail;
25002  }
25003 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25004  if ( !args(1).isempty() )
25005 #else
25006  if ( !args(1).is_empty() )
25007 #endif
25008  {
25009  if ( _dim( args(1), 0 ) != Alen )
25010  {
25011  error( "argument vectors must be same length" ); SWIG_fail;
25012  }
25013  temp2 = args(1).matrix_value();
25014  arg2 = &temp2( 0, 0 );
25015  arg3 = (PLINT) ( _dim( args(1), 0 ) );
25016  }
25017  else
25018  {
25019  arg2 = NULL;
25020  arg3 = 0;
25021  }
25022  }
25023  ecode4 = SWIG_AsVal_int(args(2), &val4);
25024  if (!SWIG_IsOK(ecode4)) {
25025  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
25026  }
25027  arg4 = static_cast< PLBOOL >(val4);
25028  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
25029  _outv = octave_value();
25030  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25031  {
25032 
25033  }
25034  {
25035 
25036  }
25037  return _out;
25038  fail:
25039  {
25040 
25041  }
25042  {
25043 
25044  }
25045  return octave_value_list();
25046  }
25047  catch(...) {
25048  {
25049 
25050  }
25051  {
25052 
25053  }
25054  throw;
25055  }
25056 }
25057 
25058 
25060  PLFLT arg1 ;
25061  PLFLT arg2 ;
25062  PLFLT arg3 ;
25063  PLFLT arg4 ;
25064  double val1 ;
25065  int ecode1 = 0 ;
25066  double val2 ;
25067  int ecode2 = 0 ;
25068  double val3 ;
25069  int ecode3 = 0 ;
25070  double val4 ;
25071  int ecode4 = 0 ;
25072  octave_value_list _out;
25073  octave_value_list *_outp=&_out;
25074  octave_value _outv;
25075 
25076  try {
25077  if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
25078  SWIG_fail;
25079  }
25080  ecode1 = SWIG_AsVal_double(args(0), &val1);
25081  if (!SWIG_IsOK(ecode1)) {
25082  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
25083  }
25084  arg1 = static_cast< PLFLT >(val1);
25085  ecode2 = SWIG_AsVal_double(args(1), &val2);
25086  if (!SWIG_IsOK(ecode2)) {
25087  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
25088  }
25089  arg2 = static_cast< PLFLT >(val2);
25090  ecode3 = SWIG_AsVal_double(args(2), &val3);
25091  if (!SWIG_IsOK(ecode3)) {
25092  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
25093  }
25094  arg3 = static_cast< PLFLT >(val3);
25095  ecode4 = SWIG_AsVal_double(args(3), &val4);
25096  if (!SWIG_IsOK(ecode4)) {
25097  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
25098  }
25099  arg4 = static_cast< PLFLT >(val4);
25100  plsvpa(arg1,arg2,arg3,arg4);
25101  _outv = octave_value();
25102  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25103  return _out;
25104  fail:
25105  return octave_value_list();
25106  }
25107  catch(...) {
25108  throw;
25109  }
25110 }
25111 
25112 
25114  PLINT arg1 ;
25115  PLINT arg2 ;
25116  int val1 ;
25117  int ecode1 = 0 ;
25118  int val2 ;
25119  int ecode2 = 0 ;
25120  octave_value_list _out;
25121  octave_value_list *_outp=&_out;
25122  octave_value _outv;
25123 
25124  try {
25125  if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
25126  SWIG_fail;
25127  }
25128  ecode1 = SWIG_AsVal_int(args(0), &val1);
25129  if (!SWIG_IsOK(ecode1)) {
25130  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
25131  }
25132  arg1 = static_cast< PLINT >(val1);
25133  ecode2 = SWIG_AsVal_int(args(1), &val2);
25134  if (!SWIG_IsOK(ecode2)) {
25135  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
25136  }
25137  arg2 = static_cast< PLINT >(val2);
25138  plsxax(arg1,arg2);
25139  _outv = octave_value();
25140  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25141  return _out;
25142  fail:
25143  return octave_value_list();
25144  }
25145  catch(...) {
25146  throw;
25147  }
25148 }
25149 
25150 
25152  PLINT arg1 ;
25153  PLINT arg2 ;
25154  int val1 ;
25155  int ecode1 = 0 ;
25156  int val2 ;
25157  int ecode2 = 0 ;
25158  octave_value_list _out;
25159  octave_value_list *_outp=&_out;
25160  octave_value _outv;
25161 
25162  try {
25163  if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
25164  SWIG_fail;
25165  }
25166  ecode1 = SWIG_AsVal_int(args(0), &val1);
25167  if (!SWIG_IsOK(ecode1)) {
25168  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
25169  }
25170  arg1 = static_cast< PLINT >(val1);
25171  ecode2 = SWIG_AsVal_int(args(1), &val2);
25172  if (!SWIG_IsOK(ecode2)) {
25173  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
25174  }
25175  arg2 = static_cast< PLINT >(val2);
25176  plsyax(arg1,arg2);
25177  _outv = octave_value();
25178  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25179  return _out;
25180  fail:
25181  return octave_value_list();
25182  }
25183  catch(...) {
25184  throw;
25185  }
25186 }
25187 
25188 
25190  PLINT arg1 ;
25191  PLFLT *arg2 = (PLFLT *) 0 ;
25192  PLFLT *arg3 = (PLFLT *) 0 ;
25193  PLINT arg4 ;
25194  Matrix temp1 ;
25195  Matrix temp3 ;
25196  int val4 ;
25197  int ecode4 = 0 ;
25198  octave_value_list _out;
25199  octave_value_list *_outp=&_out;
25200  octave_value _outv;
25201 
25202  try {
25203  if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
25204  SWIG_fail;
25205  }
25206  {
25207  if ( _n_dims( args(0) ) > 1 )
25208  {
25209  error( "argument must be a scalar or vector" ); SWIG_fail;
25210  }
25211  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25212  temp1 = args(0).matrix_value();
25213  arg2 = &temp1( 0, 0 );
25214  }
25215  {
25216  if ( _n_dims( args(1) ) > 1 )
25217  {
25218  error( "argument must be a scalar or vector" ); SWIG_fail;
25219  }
25220  if ( _dim( args(1), 0 ) != Alen )
25221  {
25222  error( "argument vectors must be same length" ); SWIG_fail;
25223  }
25224  temp3 = args(1).matrix_value();
25225  arg3 = &temp3( 0, 0 );
25226  }
25227  ecode4 = SWIG_AsVal_int(args(2), &val4);
25228  if (!SWIG_IsOK(ecode4)) {
25229  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
25230  }
25231  arg4 = static_cast< PLINT >(val4);
25232  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
25233  _outv = octave_value();
25234  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25235  {
25236 
25237  }
25238  {
25239 
25240  }
25241  return _out;
25242  fail:
25243  {
25244 
25245  }
25246  {
25247 
25248  }
25249  return octave_value_list();
25250  }
25251  catch(...) {
25252  {
25253 
25254  }
25255  {
25256 
25257  }
25258  throw;
25259  }
25260 }
25261 
25262 
25264  PLINT arg1 ;
25265  PLINT arg2 ;
25266  int val1 ;
25267  int ecode1 = 0 ;
25268  int val2 ;
25269  int ecode2 = 0 ;
25270  octave_value_list _out;
25271  octave_value_list *_outp=&_out;
25272  octave_value _outv;
25273 
25274  try {
25275  if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
25276  SWIG_fail;
25277  }
25278  ecode1 = SWIG_AsVal_int(args(0), &val1);
25279  if (!SWIG_IsOK(ecode1)) {
25280  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
25281  }
25282  arg1 = static_cast< PLINT >(val1);
25283  ecode2 = SWIG_AsVal_int(args(1), &val2);
25284  if (!SWIG_IsOK(ecode2)) {
25285  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
25286  }
25287  arg2 = static_cast< PLINT >(val2);
25288  plszax(arg1,arg2);
25289  _outv = octave_value();
25290  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25291  return _out;
25292  fail:
25293  return octave_value_list();
25294  }
25295  catch(...) {
25296  throw;
25297  }
25298 }
25299 
25300 
25302  octave_value_list _out;
25303  octave_value_list *_outp=&_out;
25304  octave_value _outv;
25305 
25306  try {
25307  if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
25308  SWIG_fail;
25309  }
25310  pltext();
25311  _outv = octave_value();
25312  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25313  return _out;
25314  fail:
25315  return octave_value_list();
25316  }
25317  catch(...) {
25318  throw;
25319  }
25320 }
25321 
25322 
25324  char *arg1 = (char *) 0 ;
25325  int res1 ;
25326  char *buf1 = 0 ;
25327  int alloc1 = 0 ;
25328  octave_value_list _out;
25329  octave_value_list *_outp=&_out;
25330  octave_value _outv;
25331 
25332  try {
25333  if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
25334  SWIG_fail;
25335  }
25336  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
25337  if (!SWIG_IsOK(res1)) {
25338  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
25339  }
25340  arg1 = reinterpret_cast< char * >(buf1);
25341  pltimefmt((char const *)arg1);
25342  _outv = octave_value();
25343  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25344  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25345  return _out;
25346  fail:
25347  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25348  return octave_value_list();
25349  }
25350  catch(...) {
25351  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25352  throw;
25353  }
25354 }
25355 
25356 
25358  PLFLT arg1 ;
25359  double val1 ;
25360  int ecode1 = 0 ;
25361  octave_value_list _out;
25362  octave_value_list *_outp=&_out;
25363  octave_value _outv;
25364 
25365  try {
25366  if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
25367  SWIG_fail;
25368  }
25369  ecode1 = SWIG_AsVal_double(args(0), &val1);
25370  if (!SWIG_IsOK(ecode1)) {
25371  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
25372  }
25373  arg1 = static_cast< PLFLT >(val1);
25374  plvasp(arg1);
25375  _outv = octave_value();
25376  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25377  return _out;
25378  fail:
25379  return octave_value_list();
25380  }
25381  catch(...) {
25382  throw;
25383  }
25384 }
25385 
25386 
25388  PLFLT arg1 ;
25389  PLFLT arg2 ;
25390  PLFLT arg3 ;
25391  PLFLT arg4 ;
25392  PLFLT arg5 ;
25393  double val1 ;
25394  int ecode1 = 0 ;
25395  double val2 ;
25396  int ecode2 = 0 ;
25397  double val3 ;
25398  int ecode3 = 0 ;
25399  double val4 ;
25400  int ecode4 = 0 ;
25401  double val5 ;
25402  int ecode5 = 0 ;
25403  octave_value_list _out;
25404  octave_value_list *_outp=&_out;
25405  octave_value _outv;
25406 
25407  try {
25408  if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
25409  SWIG_fail;
25410  }
25411  ecode1 = SWIG_AsVal_double(args(0), &val1);
25412  if (!SWIG_IsOK(ecode1)) {
25413  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
25414  }
25415  arg1 = static_cast< PLFLT >(val1);
25416  ecode2 = SWIG_AsVal_double(args(1), &val2);
25417  if (!SWIG_IsOK(ecode2)) {
25418  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
25419  }
25420  arg2 = static_cast< PLFLT >(val2);
25421  ecode3 = SWIG_AsVal_double(args(2), &val3);
25422  if (!SWIG_IsOK(ecode3)) {
25423  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
25424  }
25425  arg3 = static_cast< PLFLT >(val3);
25426  ecode4 = SWIG_AsVal_double(args(3), &val4);
25427  if (!SWIG_IsOK(ecode4)) {
25428  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
25429  }
25430  arg4 = static_cast< PLFLT >(val4);
25431  ecode5 = SWIG_AsVal_double(args(4), &val5);
25432  if (!SWIG_IsOK(ecode5)) {
25433  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
25434  }
25435  arg5 = static_cast< PLFLT >(val5);
25436  plvpas(arg1,arg2,arg3,arg4,arg5);
25437  _outv = octave_value();
25438  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25439  return _out;
25440  fail:
25441  return octave_value_list();
25442  }
25443  catch(...) {
25444  throw;
25445  }
25446 }
25447 
25448 
25450  PLFLT arg1 ;
25451  PLFLT arg2 ;
25452  PLFLT arg3 ;
25453  PLFLT arg4 ;
25454  double val1 ;
25455  int ecode1 = 0 ;
25456  double val2 ;
25457  int ecode2 = 0 ;
25458  double val3 ;
25459  int ecode3 = 0 ;
25460  double val4 ;
25461  int ecode4 = 0 ;
25462  octave_value_list _out;
25463  octave_value_list *_outp=&_out;
25464  octave_value _outv;
25465 
25466  try {
25467  if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
25468  SWIG_fail;
25469  }
25470  ecode1 = SWIG_AsVal_double(args(0), &val1);
25471  if (!SWIG_IsOK(ecode1)) {
25472  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
25473  }
25474  arg1 = static_cast< PLFLT >(val1);
25475  ecode2 = SWIG_AsVal_double(args(1), &val2);
25476  if (!SWIG_IsOK(ecode2)) {
25477  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
25478  }
25479  arg2 = static_cast< PLFLT >(val2);
25480  ecode3 = SWIG_AsVal_double(args(2), &val3);
25481  if (!SWIG_IsOK(ecode3)) {
25482  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
25483  }
25484  arg3 = static_cast< PLFLT >(val3);
25485  ecode4 = SWIG_AsVal_double(args(3), &val4);
25486  if (!SWIG_IsOK(ecode4)) {
25487  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
25488  }
25489  arg4 = static_cast< PLFLT >(val4);
25490  plvpor(arg1,arg2,arg3,arg4);
25491  _outv = octave_value();
25492  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25493  return _out;
25494  fail:
25495  return octave_value_list();
25496  }
25497  catch(...) {
25498  throw;
25499  }
25500 }
25501 
25502 
25504  octave_value_list _out;
25505  octave_value_list *_outp=&_out;
25506  octave_value _outv;
25507 
25508  try {
25509  if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
25510  SWIG_fail;
25511  }
25512  plvsta();
25513  _outv = octave_value();
25514  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25515  return _out;
25516  fail:
25517  return octave_value_list();
25518  }
25519  catch(...) {
25520  throw;
25521  }
25522 }
25523 
25524 
25526  PLFLT arg1 ;
25527  PLFLT arg2 ;
25528  PLFLT arg3 ;
25529  PLFLT arg4 ;
25530  PLFLT arg5 ;
25531  PLFLT arg6 ;
25532  PLFLT arg7 ;
25533  PLFLT arg8 ;
25534  PLFLT arg9 ;
25535  PLFLT arg10 ;
25536  PLFLT arg11 ;
25537  double val1 ;
25538  int ecode1 = 0 ;
25539  double val2 ;
25540  int ecode2 = 0 ;
25541  double val3 ;
25542  int ecode3 = 0 ;
25543  double val4 ;
25544  int ecode4 = 0 ;
25545  double val5 ;
25546  int ecode5 = 0 ;
25547  double val6 ;
25548  int ecode6 = 0 ;
25549  double val7 ;
25550  int ecode7 = 0 ;
25551  double val8 ;
25552  int ecode8 = 0 ;
25553  double val9 ;
25554  int ecode9 = 0 ;
25555  double val10 ;
25556  int ecode10 = 0 ;
25557  double val11 ;
25558  int ecode11 = 0 ;
25559  octave_value_list _out;
25560  octave_value_list *_outp=&_out;
25561  octave_value _outv;
25562 
25563  try {
25564  if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
25565  SWIG_fail;
25566  }
25567  ecode1 = SWIG_AsVal_double(args(0), &val1);
25568  if (!SWIG_IsOK(ecode1)) {
25569  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
25570  }
25571  arg1 = static_cast< PLFLT >(val1);
25572  ecode2 = SWIG_AsVal_double(args(1), &val2);
25573  if (!SWIG_IsOK(ecode2)) {
25574  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
25575  }
25576  arg2 = static_cast< PLFLT >(val2);
25577  ecode3 = SWIG_AsVal_double(args(2), &val3);
25578  if (!SWIG_IsOK(ecode3)) {
25579  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
25580  }
25581  arg3 = static_cast< PLFLT >(val3);
25582  ecode4 = SWIG_AsVal_double(args(3), &val4);
25583  if (!SWIG_IsOK(ecode4)) {
25584  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
25585  }
25586  arg4 = static_cast< PLFLT >(val4);
25587  ecode5 = SWIG_AsVal_double(args(4), &val5);
25588  if (!SWIG_IsOK(ecode5)) {
25589  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
25590  }
25591  arg5 = static_cast< PLFLT >(val5);
25592  ecode6 = SWIG_AsVal_double(args(5), &val6);
25593  if (!SWIG_IsOK(ecode6)) {
25594  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
25595  }
25596  arg6 = static_cast< PLFLT >(val6);
25597  ecode7 = SWIG_AsVal_double(args(6), &val7);
25598  if (!SWIG_IsOK(ecode7)) {
25599  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
25600  }
25601  arg7 = static_cast< PLFLT >(val7);
25602  ecode8 = SWIG_AsVal_double(args(7), &val8);
25603  if (!SWIG_IsOK(ecode8)) {
25604  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
25605  }
25606  arg8 = static_cast< PLFLT >(val8);
25607  ecode9 = SWIG_AsVal_double(args(8), &val9);
25608  if (!SWIG_IsOK(ecode9)) {
25609  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
25610  }
25611  arg9 = static_cast< PLFLT >(val9);
25612  ecode10 = SWIG_AsVal_double(args(9), &val10);
25613  if (!SWIG_IsOK(ecode10)) {
25614  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
25615  }
25616  arg10 = static_cast< PLFLT >(val10);
25617  ecode11 = SWIG_AsVal_double(args(10), &val11);
25618  if (!SWIG_IsOK(ecode11)) {
25619  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
25620  }
25621  arg11 = static_cast< PLFLT >(val11);
25622  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25623  _outv = octave_value();
25624  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25625  return _out;
25626  fail:
25627  return octave_value_list();
25628  }
25629  catch(...) {
25630  throw;
25631  }
25632 }
25633 
25634 
25636  PLFLT arg1 ;
25637  double val1 ;
25638  int ecode1 = 0 ;
25639  octave_value_list _out;
25640  octave_value_list *_outp=&_out;
25641  octave_value _outv;
25642 
25643  try {
25644  if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
25645  SWIG_fail;
25646  }
25647  ecode1 = SWIG_AsVal_double(args(0), &val1);
25648  if (!SWIG_IsOK(ecode1)) {
25649  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
25650  }
25651  arg1 = static_cast< PLFLT >(val1);
25652  plwidth(arg1);
25653  _outv = octave_value();
25654  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25655  return _out;
25656  fail:
25657  return octave_value_list();
25658  }
25659  catch(...) {
25660  throw;
25661  }
25662 }
25663 
25664 
25666  PLFLT arg1 ;
25667  PLFLT arg2 ;
25668  PLFLT arg3 ;
25669  PLFLT arg4 ;
25670  double val1 ;
25671  int ecode1 = 0 ;
25672  double val2 ;
25673  int ecode2 = 0 ;
25674  double val3 ;
25675  int ecode3 = 0 ;
25676  double val4 ;
25677  int ecode4 = 0 ;
25678  octave_value_list _out;
25679  octave_value_list *_outp=&_out;
25680  octave_value _outv;
25681 
25682  try {
25683  if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
25684  SWIG_fail;
25685  }
25686  ecode1 = SWIG_AsVal_double(args(0), &val1);
25687  if (!SWIG_IsOK(ecode1)) {
25688  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
25689  }
25690  arg1 = static_cast< PLFLT >(val1);
25691  ecode2 = SWIG_AsVal_double(args(1), &val2);
25692  if (!SWIG_IsOK(ecode2)) {
25693  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
25694  }
25695  arg2 = static_cast< PLFLT >(val2);
25696  ecode3 = SWIG_AsVal_double(args(2), &val3);
25697  if (!SWIG_IsOK(ecode3)) {
25698  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
25699  }
25700  arg3 = static_cast< PLFLT >(val3);
25701  ecode4 = SWIG_AsVal_double(args(3), &val4);
25702  if (!SWIG_IsOK(ecode4)) {
25703  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
25704  }
25705  arg4 = static_cast< PLFLT >(val4);
25706  plwind(arg1,arg2,arg3,arg4);
25707  _outv = octave_value();
25708  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25709  return _out;
25710  fail:
25711  return octave_value_list();
25712  }
25713  catch(...) {
25714  throw;
25715  }
25716 }
25717 
25718 
25720  PLBOOL arg1 ;
25721  PLBOOL *arg2 = (PLBOOL *) 0 ;
25722  int val1 ;
25723  int ecode1 = 0 ;
25724  PLBOOL temp2 ;
25725  int res2 = SWIG_TMPOBJ ;
25726  octave_value_list _out;
25727  octave_value_list *_outp=&_out;
25728  octave_value _outv;
25729 
25730  try {
25731  arg2 = &temp2;
25732  if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
25733  SWIG_fail;
25734  }
25735  ecode1 = SWIG_AsVal_int(args(0), &val1);
25736  if (!SWIG_IsOK(ecode1)) {
25737  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
25738  }
25739  arg1 = static_cast< PLBOOL >(val1);
25740  plxormod(arg1,arg2);
25741  _outv = octave_value();
25742  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25743  if (SWIG_IsTmpObj(res2)) {
25744  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
25745  } else {
25746  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25747  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
25748  }
25749  return _out;
25750  fail:
25751  return octave_value_list();
25752  }
25753  catch(...) {
25754  throw;
25755  }
25756 }
25757 
25758 
25760  mapform_func arg1 = (mapform_func) 0 ;
25761  char *arg2 = (char *) 0 ;
25762  PLFLT arg3 ;
25763  PLFLT arg4 ;
25764  PLFLT arg5 ;
25765  PLFLT arg6 ;
25766  int res2 ;
25767  char *buf2 = 0 ;
25768  int alloc2 = 0 ;
25769  double val3 ;
25770  int ecode3 = 0 ;
25771  double val4 ;
25772  int ecode4 = 0 ;
25773  double val5 ;
25774  int ecode5 = 0 ;
25775  double val6 ;
25776  int ecode6 = 0 ;
25777  octave_value_list _out;
25778  octave_value_list *_outp=&_out;
25779  octave_value _outv;
25780 
25781  try {
25782  if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
25783  SWIG_fail;
25784  }
25785  {
25786  octave_value obj = args(0);
25787 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25788  if ( !obj.isempty() )
25789 #else
25790  if ( !obj.is_empty() )
25791 #endif
25792  {
25793  if ( obj.is_function_handle() || obj.is_inline_function() )
25794  {
25795  fcnMapForm = obj.function_value();
25796  }
25797  else if ( obj.is_string() )
25798  {
25799  nameMapForm = obj.string_value();
25800  fcnMapForm = NULL;
25801  }
25802  arg1 = mapform_octave;
25803  }
25804  else
25805  {
25806  arg1 = NULL;
25807  }
25808  }
25809  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
25810  if (!SWIG_IsOK(res2)) {
25811  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
25812  }
25813  arg2 = reinterpret_cast< char * >(buf2);
25814  ecode3 = SWIG_AsVal_double(args(2), &val3);
25815  if (!SWIG_IsOK(ecode3)) {
25816  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
25817  }
25818  arg3 = static_cast< PLFLT >(val3);
25819  ecode4 = SWIG_AsVal_double(args(3), &val4);
25820  if (!SWIG_IsOK(ecode4)) {
25821  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
25822  }
25823  arg4 = static_cast< PLFLT >(val4);
25824  ecode5 = SWIG_AsVal_double(args(4), &val5);
25825  if (!SWIG_IsOK(ecode5)) {
25826  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
25827  }
25828  arg5 = static_cast< PLFLT >(val5);
25829  ecode6 = SWIG_AsVal_double(args(5), &val6);
25830  if (!SWIG_IsOK(ecode6)) {
25831  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
25832  }
25833  arg6 = static_cast< PLFLT >(val6);
25834  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
25835  _outv = octave_value();
25836  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25837  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25838  return _out;
25839  fail:
25840  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25841  return octave_value_list();
25842  }
25843  catch(...) {
25844  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25845  throw;
25846  }
25847 }
25848 
25849 
25851  mapform_func arg1 = (mapform_func) 0 ;
25852  char *arg2 = (char *) 0 ;
25853  PLFLT arg3 ;
25854  PLFLT arg4 ;
25855  PLFLT arg5 ;
25856  PLFLT arg6 ;
25857  PLINT *arg7 = (PLINT *) 0 ;
25858  PLINT arg8 ;
25859  int res2 ;
25860  char *buf2 = 0 ;
25861  int alloc2 = 0 ;
25862  double val3 ;
25863  int ecode3 = 0 ;
25864  double val4 ;
25865  int ecode4 = 0 ;
25866  double val5 ;
25867  int ecode5 = 0 ;
25868  double val6 ;
25869  int ecode6 = 0 ;
25870  Matrix temp7 ;
25871  octave_value_list _out;
25872  octave_value_list *_outp=&_out;
25873  octave_value _outv;
25874 
25875  try {
25876  if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
25877  SWIG_fail;
25878  }
25879  {
25880  octave_value obj = args(0);
25881 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25882  if ( !obj.isempty() )
25883 #else
25884  if ( !obj.is_empty() )
25885 #endif
25886  {
25887  if ( obj.is_function_handle() || obj.is_inline_function() )
25888  {
25889  fcnMapForm = obj.function_value();
25890  }
25891  else if ( obj.is_string() )
25892  {
25893  nameMapForm = obj.string_value();
25894  fcnMapForm = NULL;
25895  }
25896  arg1 = mapform_octave;
25897  }
25898  else
25899  {
25900  arg1 = NULL;
25901  }
25902  }
25903  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
25904  if (!SWIG_IsOK(res2)) {
25905  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
25906  }
25907  arg2 = reinterpret_cast< char * >(buf2);
25908  ecode3 = SWIG_AsVal_double(args(2), &val3);
25909  if (!SWIG_IsOK(ecode3)) {
25910  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
25911  }
25912  arg3 = static_cast< PLFLT >(val3);
25913  ecode4 = SWIG_AsVal_double(args(3), &val4);
25914  if (!SWIG_IsOK(ecode4)) {
25915  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
25916  }
25917  arg4 = static_cast< PLFLT >(val4);
25918  ecode5 = SWIG_AsVal_double(args(4), &val5);
25919  if (!SWIG_IsOK(ecode5)) {
25920  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
25921  }
25922  arg5 = static_cast< PLFLT >(val5);
25923  ecode6 = SWIG_AsVal_double(args(5), &val6);
25924  if (!SWIG_IsOK(ecode6)) {
25925  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
25926  }
25927  arg6 = static_cast< PLFLT >(val6);
25928  {
25929  if ( _n_dims( args(6) ) > 1 )
25930  {
25931  error( "argument must be a scalar or vector" ); SWIG_fail;
25932  }
25933 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25934  if ( !args(6).isempty() )
25935 #else
25936  if ( !args(6).is_empty() )
25937 #endif
25938  {
25939  arg8 = (PLINT) ( _dim( args(6), 0 ) );
25940  temp7 = args(6).matrix_value();
25941  arg7 = new PLINT[arg8];
25942  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
25943  }
25944  else
25945  {
25946  arg7 = NULL;
25947  arg8 = 0;
25948  }
25949  }
25950  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
25951  _outv = octave_value();
25952  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25953  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25954  {
25955  delete [] arg7;
25956  }
25957  return _out;
25958  fail:
25959  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25960  {
25961  delete [] arg7;
25962  }
25963  return octave_value_list();
25964  }
25965  catch(...) {
25966  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25967  {
25968  delete [] arg7;
25969  }
25970  throw;
25971  }
25972 }
25973 
25974 
25976  mapform_func arg1 = (mapform_func) 0 ;
25977  char *arg2 = (char *) 0 ;
25978  char *arg3 = (char *) 0 ;
25979  PLFLT arg4 ;
25980  PLFLT arg5 ;
25981  PLFLT arg6 ;
25982  PLFLT arg7 ;
25983  PLINT *arg8 = (PLINT *) 0 ;
25984  PLINT arg9 ;
25985  int res2 ;
25986  char *buf2 = 0 ;
25987  int alloc2 = 0 ;
25988  int res3 ;
25989  char *buf3 = 0 ;
25990  int alloc3 = 0 ;
25991  double val4 ;
25992  int ecode4 = 0 ;
25993  double val5 ;
25994  int ecode5 = 0 ;
25995  double val6 ;
25996  int ecode6 = 0 ;
25997  double val7 ;
25998  int ecode7 = 0 ;
25999  Matrix temp8 ;
26000  octave_value_list _out;
26001  octave_value_list *_outp=&_out;
26002  octave_value _outv;
26003 
26004  try {
26005  if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
26006  SWIG_fail;
26007  }
26008  {
26009  octave_value obj = args(0);
26010 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26011  if ( !obj.isempty() )
26012 #else
26013  if ( !obj.is_empty() )
26014 #endif
26015  {
26016  if ( obj.is_function_handle() || obj.is_inline_function() )
26017  {
26018  fcnMapForm = obj.function_value();
26019  }
26020  else if ( obj.is_string() )
26021  {
26022  nameMapForm = obj.string_value();
26023  fcnMapForm = NULL;
26024  }
26025  arg1 = mapform_octave;
26026  }
26027  else
26028  {
26029  arg1 = NULL;
26030  }
26031  }
26032  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26033  if (!SWIG_IsOK(res2)) {
26034  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
26035  }
26036  arg2 = reinterpret_cast< char * >(buf2);
26037  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
26038  if (!SWIG_IsOK(res3)) {
26039  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
26040  }
26041  arg3 = reinterpret_cast< char * >(buf3);
26042  ecode4 = SWIG_AsVal_double(args(3), &val4);
26043  if (!SWIG_IsOK(ecode4)) {
26044  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
26045  }
26046  arg4 = static_cast< PLFLT >(val4);
26047  ecode5 = SWIG_AsVal_double(args(4), &val5);
26048  if (!SWIG_IsOK(ecode5)) {
26049  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
26050  }
26051  arg5 = static_cast< PLFLT >(val5);
26052  ecode6 = SWIG_AsVal_double(args(5), &val6);
26053  if (!SWIG_IsOK(ecode6)) {
26054  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
26055  }
26056  arg6 = static_cast< PLFLT >(val6);
26057  ecode7 = SWIG_AsVal_double(args(6), &val7);
26058  if (!SWIG_IsOK(ecode7)) {
26059  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
26060  }
26061  arg7 = static_cast< PLFLT >(val7);
26062  {
26063  if ( _n_dims( args(7) ) > 1 )
26064  {
26065  error( "argument must be a scalar or vector" ); SWIG_fail;
26066  }
26067 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26068  if ( !args(7).isempty() )
26069 #else
26070  if ( !args(7).is_empty() )
26071 #endif
26072  {
26073  arg9 = (PLINT) ( _dim( args(7), 0 ) );
26074  temp8 = args(7).matrix_value();
26075  arg8 = new PLINT[arg9];
26076  _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
26077  }
26078  else
26079  {
26080  arg8 = NULL;
26081  arg9 = 0;
26082  }
26083  }
26084  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
26085  _outv = octave_value();
26086  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26087  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26088  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26089  {
26090  delete [] arg8;
26091  }
26092  return _out;
26093  fail:
26094  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26095  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26096  {
26097  delete [] arg8;
26098  }
26099  return octave_value_list();
26100  }
26101  catch(...) {
26102  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26103  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26104  {
26105  delete [] arg8;
26106  }
26107  throw;
26108  }
26109 }
26110 
26111 
26113  mapform_func arg1 = (mapform_func) 0 ;
26114  char *arg2 = (char *) 0 ;
26115  PLFLT arg3 ;
26116  PLFLT arg4 ;
26117  PLFLT arg5 ;
26118  char *arg6 = (char *) 0 ;
26119  PLFLT arg7 ;
26120  PLFLT arg8 ;
26121  PLFLT arg9 ;
26122  PLFLT arg10 ;
26123  PLINT arg11 ;
26124  int res2 ;
26125  char *buf2 = 0 ;
26126  int alloc2 = 0 ;
26127  double val3 ;
26128  int ecode3 = 0 ;
26129  double val4 ;
26130  int ecode4 = 0 ;
26131  double val5 ;
26132  int ecode5 = 0 ;
26133  int res6 ;
26134  char *buf6 = 0 ;
26135  int alloc6 = 0 ;
26136  double val7 ;
26137  int ecode7 = 0 ;
26138  double val8 ;
26139  int ecode8 = 0 ;
26140  double val9 ;
26141  int ecode9 = 0 ;
26142  double val10 ;
26143  int ecode10 = 0 ;
26144  int val11 ;
26145  int ecode11 = 0 ;
26146  octave_value_list _out;
26147  octave_value_list *_outp=&_out;
26148  octave_value _outv;
26149 
26150  try {
26151  if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
26152  SWIG_fail;
26153  }
26154  {
26155  octave_value obj = args(0);
26156 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26157  if ( !obj.isempty() )
26158 #else
26159  if ( !obj.is_empty() )
26160 #endif
26161  {
26162  if ( obj.is_function_handle() || obj.is_inline_function() )
26163  {
26164  fcnMapForm = obj.function_value();
26165  }
26166  else if ( obj.is_string() )
26167  {
26168  nameMapForm = obj.string_value();
26169  fcnMapForm = NULL;
26170  }
26171  arg1 = mapform_octave;
26172  }
26173  else
26174  {
26175  arg1 = NULL;
26176  }
26177  }
26178  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26179  if (!SWIG_IsOK(res2)) {
26180  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
26181  }
26182  arg2 = reinterpret_cast< char * >(buf2);
26183  ecode3 = SWIG_AsVal_double(args(2), &val3);
26184  if (!SWIG_IsOK(ecode3)) {
26185  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
26186  }
26187  arg3 = static_cast< PLFLT >(val3);
26188  ecode4 = SWIG_AsVal_double(args(3), &val4);
26189  if (!SWIG_IsOK(ecode4)) {
26190  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
26191  }
26192  arg4 = static_cast< PLFLT >(val4);
26193  ecode5 = SWIG_AsVal_double(args(4), &val5);
26194  if (!SWIG_IsOK(ecode5)) {
26195  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
26196  }
26197  arg5 = static_cast< PLFLT >(val5);
26198  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
26199  if (!SWIG_IsOK(res6)) {
26200  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
26201  }
26202  arg6 = reinterpret_cast< char * >(buf6);
26203  ecode7 = SWIG_AsVal_double(args(6), &val7);
26204  if (!SWIG_IsOK(ecode7)) {
26205  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
26206  }
26207  arg7 = static_cast< PLFLT >(val7);
26208  ecode8 = SWIG_AsVal_double(args(7), &val8);
26209  if (!SWIG_IsOK(ecode8)) {
26210  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
26211  }
26212  arg8 = static_cast< PLFLT >(val8);
26213  ecode9 = SWIG_AsVal_double(args(8), &val9);
26214  if (!SWIG_IsOK(ecode9)) {
26215  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
26216  }
26217  arg9 = static_cast< PLFLT >(val9);
26218  ecode10 = SWIG_AsVal_double(args(9), &val10);
26219  if (!SWIG_IsOK(ecode10)) {
26220  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
26221  }
26222  arg10 = static_cast< PLFLT >(val10);
26223  ecode11 = SWIG_AsVal_int(args(10), &val11);
26224  if (!SWIG_IsOK(ecode11)) {
26225  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
26226  }
26227  arg11 = static_cast< PLINT >(val11);
26228  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26229  _outv = octave_value();
26230  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26231  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26232  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26233  return _out;
26234  fail:
26235  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26236  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26237  return octave_value_list();
26238  }
26239  catch(...) {
26240  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26241  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26242  throw;
26243  }
26244 }
26245 
26246 
26248  mapform_func arg1 = (mapform_func) 0 ;
26249  char *arg2 = (char *) 0 ;
26250  PLFLT arg3 ;
26251  PLFLT arg4 ;
26252  PLFLT arg5 ;
26253  PLFLT arg6 ;
26254  PLINT *arg7 = (PLINT *) 0 ;
26255  PLINT arg8 ;
26256  int res2 ;
26257  char *buf2 = 0 ;
26258  int alloc2 = 0 ;
26259  double val3 ;
26260  int ecode3 = 0 ;
26261  double val4 ;
26262  int ecode4 = 0 ;
26263  double val5 ;
26264  int ecode5 = 0 ;
26265  double val6 ;
26266  int ecode6 = 0 ;
26267  Matrix temp7 ;
26268  octave_value_list _out;
26269  octave_value_list *_outp=&_out;
26270  octave_value _outv;
26271 
26272  try {
26273  if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
26274  SWIG_fail;
26275  }
26276  {
26277  octave_value obj = args(0);
26278 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26279  if ( !obj.isempty() )
26280 #else
26281  if ( !obj.is_empty() )
26282 #endif
26283  {
26284  if ( obj.is_function_handle() || obj.is_inline_function() )
26285  {
26286  fcnMapForm = obj.function_value();
26287  }
26288  else if ( obj.is_string() )
26289  {
26290  nameMapForm = obj.string_value();
26291  fcnMapForm = NULL;
26292  }
26293  arg1 = mapform_octave;
26294  }
26295  else
26296  {
26297  arg1 = NULL;
26298  }
26299  }
26300  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26301  if (!SWIG_IsOK(res2)) {
26302  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
26303  }
26304  arg2 = reinterpret_cast< char * >(buf2);
26305  ecode3 = SWIG_AsVal_double(args(2), &val3);
26306  if (!SWIG_IsOK(ecode3)) {
26307  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
26308  }
26309  arg3 = static_cast< PLFLT >(val3);
26310  ecode4 = SWIG_AsVal_double(args(3), &val4);
26311  if (!SWIG_IsOK(ecode4)) {
26312  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
26313  }
26314  arg4 = static_cast< PLFLT >(val4);
26315  ecode5 = SWIG_AsVal_double(args(4), &val5);
26316  if (!SWIG_IsOK(ecode5)) {
26317  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
26318  }
26319  arg5 = static_cast< PLFLT >(val5);
26320  ecode6 = SWIG_AsVal_double(args(5), &val6);
26321  if (!SWIG_IsOK(ecode6)) {
26322  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
26323  }
26324  arg6 = static_cast< PLFLT >(val6);
26325  {
26326  if ( _n_dims( args(6) ) > 1 )
26327  {
26328  error( "argument must be a scalar or vector" ); SWIG_fail;
26329  }
26330 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26331  if ( !args(6).isempty() )
26332 #else
26333  if ( !args(6).is_empty() )
26334 #endif
26335  {
26336  arg8 = (PLINT) ( _dim( args(6), 0 ) );
26337  temp7 = args(6).matrix_value();
26338  arg7 = new PLINT[arg8];
26339  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26340  }
26341  else
26342  {
26343  arg7 = NULL;
26344  arg8 = 0;
26345  }
26346  }
26347  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26348  _outv = octave_value();
26349  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26350  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26351  {
26352  delete [] arg7;
26353  }
26354  return _out;
26355  fail:
26356  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26357  {
26358  delete [] arg7;
26359  }
26360  return octave_value_list();
26361  }
26362  catch(...) {
26363  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26364  {
26365  delete [] arg7;
26366  }
26367  throw;
26368  }
26369 }
26370 
26371 
26373  mapform_func arg1 = (mapform_func) 0 ;
26374  PLFLT arg2 ;
26375  PLFLT arg3 ;
26376  PLFLT arg4 ;
26377  PLFLT arg5 ;
26378  PLFLT arg6 ;
26379  PLFLT arg7 ;
26380  double val2 ;
26381  int ecode2 = 0 ;
26382  double val3 ;
26383  int ecode3 = 0 ;
26384  double val4 ;
26385  int ecode4 = 0 ;
26386  double val5 ;
26387  int ecode5 = 0 ;
26388  double val6 ;
26389  int ecode6 = 0 ;
26390  double val7 ;
26391  int ecode7 = 0 ;
26392  octave_value_list _out;
26393  octave_value_list *_outp=&_out;
26394  octave_value _outv;
26395 
26396  try {
26397  if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
26398  SWIG_fail;
26399  }
26400  {
26401  octave_value obj = args(0);
26402 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26403  if ( !obj.isempty() )
26404 #else
26405  if ( !obj.is_empty() )
26406 #endif
26407  {
26408  if ( obj.is_function_handle() || obj.is_inline_function() )
26409  {
26410  fcnMapForm = obj.function_value();
26411  }
26412  else if ( obj.is_string() )
26413  {
26414  nameMapForm = obj.string_value();
26415  fcnMapForm = NULL;
26416  }
26417  arg1 = mapform_octave;
26418  }
26419  else
26420  {
26421  arg1 = NULL;
26422  }
26423  }
26424  ecode2 = SWIG_AsVal_double(args(1), &val2);
26425  if (!SWIG_IsOK(ecode2)) {
26426  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
26427  }
26428  arg2 = static_cast< PLFLT >(val2);
26429  ecode3 = SWIG_AsVal_double(args(2), &val3);
26430  if (!SWIG_IsOK(ecode3)) {
26431  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
26432  }
26433  arg3 = static_cast< PLFLT >(val3);
26434  ecode4 = SWIG_AsVal_double(args(3), &val4);
26435  if (!SWIG_IsOK(ecode4)) {
26436  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
26437  }
26438  arg4 = static_cast< PLFLT >(val4);
26439  ecode5 = SWIG_AsVal_double(args(4), &val5);
26440  if (!SWIG_IsOK(ecode5)) {
26441  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
26442  }
26443  arg5 = static_cast< PLFLT >(val5);
26444  ecode6 = SWIG_AsVal_double(args(5), &val6);
26445  if (!SWIG_IsOK(ecode6)) {
26446  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
26447  }
26448  arg6 = static_cast< PLFLT >(val6);
26449  ecode7 = SWIG_AsVal_double(args(6), &val7);
26450  if (!SWIG_IsOK(ecode7)) {
26451  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
26452  }
26453  arg7 = static_cast< PLFLT >(val7);
26454  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
26455  _outv = octave_value();
26456  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26457  return _out;
26458  fail:
26459  return octave_value_list();
26460  }
26461  catch(...) {
26462  throw;
26463  }
26464 }
26465 
26466 
26468  octave_value_list _out;
26469  octave_value_list *_outp=&_out;
26470  octave_value _outv;
26471 
26472  try {
26473  if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
26474  SWIG_fail;
26475  }
26476  plClearOpts();
26477  _outv = octave_value();
26478  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26479  return _out;
26480  fail:
26481  return octave_value_list();
26482  }
26483  catch(...) {
26484  throw;
26485  }
26486 }
26487 
26488 
26490  octave_value_list _out;
26491  octave_value_list *_outp=&_out;
26492  octave_value _outv;
26493 
26494  try {
26495  if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
26496  SWIG_fail;
26497  }
26498  plResetOpts();
26499  _outv = octave_value();
26500  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26501  return _out;
26502  fail:
26503  return octave_value_list();
26504  }
26505  catch(...) {
26506  throw;
26507  }
26508 }
26509 
26510 
26512  char *arg1 = (char *) 0 ;
26513  char *arg2 = (char *) 0 ;
26514  int res1 ;
26515  char *buf1 = 0 ;
26516  int alloc1 = 0 ;
26517  int res2 ;
26518  char *buf2 = 0 ;
26519  int alloc2 = 0 ;
26520  octave_value_list _out;
26521  octave_value_list *_outp=&_out;
26522  octave_value _outv;
26523 
26524  try {
26525  if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
26526  SWIG_fail;
26527  }
26528  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
26529  if (!SWIG_IsOK(res1)) {
26530  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
26531  }
26532  arg1 = reinterpret_cast< char * >(buf1);
26533  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26534  if (!SWIG_IsOK(res2)) {
26535  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
26536  }
26537  arg2 = reinterpret_cast< char * >(buf2);
26538  plSetUsage((char const *)arg1,(char const *)arg2);
26539  _outv = octave_value();
26540  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26541  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26542  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26543  return _out;
26544  fail:
26545  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26546  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26547  return octave_value_list();
26548  }
26549  catch(...) {
26550  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26551  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26552  throw;
26553  }
26554 }
26555 
26556 
26558  octave_value_list _out;
26559  octave_value_list *_outp=&_out;
26560  octave_value _outv;
26561 
26562  try {
26563  if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
26564  SWIG_fail;
26565  }
26566  plOptUsage();
26567  _outv = octave_value();
26568  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26569  return _out;
26570  fail:
26571  return octave_value_list();
26572  }
26573  catch(...) {
26574  throw;
26575  }
26576 }
26577 
26578 
26579 
26580 static const struct swig_octave_member swig_globals[] = {
26581 {"testppchar",_wrap_testppchar,0,0,2,0},
26582 {"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
26583 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26584 {"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
26585 {"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
26586 {"plcont0",_wrap_plcont0,0,0,2,0},
26587 {"plcont1",_wrap_plcont1,0,0,2,0},
26588 {"plcont2",_wrap_plcont2,0,0,2,0},
26589 {"plcont2p",_wrap_plcont2p,0,0,2,0},
26590 {"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
26591 {"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
26592 {"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
26593 {"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
26594 {"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
26595 {"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
26596 {"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
26597 {"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
26598 {"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
26599 {"plshade1",_wrap_plshade1,0,0,2,0},
26600 {"plshade2",_wrap_plshade2,0,0,2,0},
26601 {"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
26602 {"plshadesx",_wrap_plshadesx,0,0,2,0},
26603 {"plshades1",_wrap_plshades1,0,0,2,0},
26604 {"plshades2",_wrap_plshades2,0,0,2,0},
26605 {"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
26606 {"plvect1",_wrap_plvect1,0,0,2,0},
26607 {"plvect2",_wrap_plvect2,0,0,2,0},
26608 {"pplimage",_wrap_pplimage,0,0,2,0},
26609 {"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
26610 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26611 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26612 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26613 {"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
26614 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
26615 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
26616 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
26617 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
26618 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
26619 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
26620 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
26621 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
26622 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
26623 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
26624 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
26625 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
26626 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
26627 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
26628 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
26629 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
26630 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
26631 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
26632 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
26633 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
26634 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
26635 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
26636 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
26637 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
26638 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
26639 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
26641 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
26642 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
26643 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
26644 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
26645 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
26646 {"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
26647 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
26648 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
26649 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
26650 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
26651 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
26652 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
26653 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
26654 {"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
26655 {"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
26656 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
26657 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
26658 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
26659 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
26660 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
26661 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
26662 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
26663 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
26664 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
26665 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
26666 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
26667 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
26668 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
26669 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
26670 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
26671 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
26672 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
26673 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
26674 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
26675 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
26676 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
26677 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
26678 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
26679 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
26680 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
26681 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
26682 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
26683 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
26684 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
26685 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
26686 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
26687 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
26688 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
26689 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
26690 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
26691 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
26692 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
26693 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
26694 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
26695 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
26696 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
26697 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
26698 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
26699 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
26700 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
26701 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
26702 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
26703 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
26704 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
26705 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
26706 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
26707 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
26708 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
26709 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
26710 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
26711 {"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
26712 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
26713 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
26714 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
26715 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
26716 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
26717 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
26718 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
26719 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
26720 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
26721 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
26722 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
26723 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
26724 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
26725 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
26726 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
26727 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
26728 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
26729 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
26730 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
26731 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
26732 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
26733 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
26734 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
26735 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
26736 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
26737 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
26738 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
26739 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
26740 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
26741 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
26742 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
26743 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
26744 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
26745 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
26746 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
26747 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
26748 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
26749 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
26750 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
26751 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
26752 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
26753 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
26754 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
26755 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
26756 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
26757 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
26758 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
26759 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
26760 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
26761 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
26762 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
26763 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
26764 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
26765 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
26766 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
26767 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
26768 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
26769 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
26770 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
26771 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
26772 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
26773 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
26774 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
26775 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
26776 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
26777 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
26778 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
26779 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
26780 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
26781 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
26782 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
26783 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
26784 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
26785 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
26786 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
26787 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
26788 {"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
26789 {"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
26790 {"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
26791 {"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
26792 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
26793 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
26794 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
26795 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
26796 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
26797 {0,0,0,0,0,0}
26798 };
26799 
26800 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
26801 
26802 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
26803 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
26804 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
26805 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};
26806 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};
26807 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};
26808 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
26809 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
26810 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
26811 
26814  &_swigt__p_char,
26819  &_swigt__p_int,
26822 };
26823 
26824 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
26825 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
26826 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
26830 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
26831 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
26832 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
26833 
26841  _swigc__p_int,
26844 };
26845 
26846 
26847 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
26848 
26849 /* -----------------------------------------------------------------------------
26850  * Type initialization:
26851  * This problem is tough by the requirement that no dynamic
26852  * memory is used. Also, since swig_type_info structures store pointers to
26853  * swig_cast_info structures and swig_cast_info structures store pointers back
26854  * to swig_type_info structures, we need some lookup code at initialization.
26855  * The idea is that swig generates all the structures that are needed.
26856  * The runtime then collects these partially filled structures.
26857  * The SWIG_InitializeModule function takes these initial arrays out of
26858  * swig_module, and does all the lookup, filling in the swig_module.types
26859  * array with the correct data and linking the correct swig_cast_info
26860  * structures together.
26861  *
26862  * The generated swig_type_info structures are assigned statically to an initial
26863  * array. We just loop through that array, and handle each type individually.
26864  * First we lookup if this type has been already loaded, and if so, use the
26865  * loaded structure instead of the generated one. Then we have to fill in the
26866  * cast linked list. The cast data is initially stored in something like a
26867  * two-dimensional array. Each row corresponds to a type (there are the same
26868  * number of rows as there are in the swig_type_initial array). Each entry in
26869  * a column is one of the swig_cast_info structures for that type.
26870  * The cast_initial array is actually an array of arrays, because each row has
26871  * a variable number of columns. So to actually build the cast linked list,
26872  * we find the array of casts associated with the type, and loop through it
26873  * adding the casts to the list. The one last trick we need to do is making
26874  * sure the type pointer in the swig_cast_info struct is correct.
26875  *
26876  * First off, we lookup the cast->type name to see if it is already loaded.
26877  * There are three cases to handle:
26878  * 1) If the cast->type has already been loaded AND the type we are adding
26879  * casting info to has not been loaded (it is in this module), THEN we
26880  * replace the cast->type pointer with the type pointer that has already
26881  * been loaded.
26882  * 2) If BOTH types (the one we are adding casting info to, and the
26883  * cast->type) are loaded, THEN the cast info has already been loaded by
26884  * the previous module so we just ignore it.
26885  * 3) Finally, if cast->type has not already been loaded, then we add that
26886  * swig_cast_info to the linked list (because the cast->type) pointer will
26887  * be correct.
26888  * ----------------------------------------------------------------------------- */
26889 
26890 #ifdef __cplusplus
26891 extern "C" {
26892 #if 0
26893 } /* c-mode */
26894 #endif
26895 #endif
26896 
26897 #if 0
26898 #define SWIGRUNTIME_DEBUG
26899 #endif
26900 
26901 
26902 SWIGRUNTIME void
26903 SWIG_InitializeModule(void *clientdata) {
26904  size_t i;
26905  swig_module_info *module_head, *iter;
26906  int init;
26907 
26908  /* check to see if the circular list has been setup, if not, set it up */
26909  if (swig_module.next==0) {
26910  /* Initialize the swig_module */
26914  init = 1;
26915  } else {
26916  init = 0;
26917  }
26918 
26919  /* Try and load any already created modules */
26920  module_head = SWIG_GetModule(clientdata);
26921  if (!module_head) {
26922  /* This is the first module loaded for this interpreter */
26923  /* so set the swig module into the interpreter */
26924  SWIG_SetModule(clientdata, &swig_module);
26925  } else {
26926  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
26927  iter=module_head;
26928  do {
26929  if (iter==&swig_module) {
26930  /* Our module is already in the list, so there's nothing more to do. */
26931  return;
26932  }
26933  iter=iter->next;
26934  } while (iter!= module_head);
26935 
26936  /* otherwise we must add our module into the list */
26937  swig_module.next = module_head->next;
26938  module_head->next = &swig_module;
26939  }
26940 
26941  /* When multiple interpreters are used, a module could have already been initialized in
26942  a different interpreter, but not yet have a pointer in this interpreter.
26943  In this case, we do not want to continue adding types... everything should be
26944  set up already */
26945  if (init == 0) return;
26946 
26947  /* Now work on filling in swig_module.types */
26948 #ifdef SWIGRUNTIME_DEBUG
26949  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
26950 #endif
26951  for (i = 0; i < swig_module.size; ++i) {
26952  swig_type_info *type = 0;
26953  swig_type_info *ret;
26955 
26956 #ifdef SWIGRUNTIME_DEBUG
26957  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
26958 #endif
26959 
26960  /* if there is another module already loaded */
26961  if (swig_module.next != &swig_module) {
26963  }
26964  if (type) {
26965  /* Overwrite clientdata field */
26966 #ifdef SWIGRUNTIME_DEBUG
26967  printf("SWIG_InitializeModule: found type %s\n", type->name);
26968 #endif
26971 #ifdef SWIGRUNTIME_DEBUG
26972  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
26973 #endif
26974  }
26975  } else {
26976  type = swig_module.type_initial[i];
26977  }
26978 
26979  /* Insert casting types */
26981  while (cast->type) {
26982 
26983  /* Don't need to add information already in the list */
26984  ret = 0;
26985 #ifdef SWIGRUNTIME_DEBUG
26986  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
26987 #endif
26988  if (swig_module.next != &swig_module) {
26990 #ifdef SWIGRUNTIME_DEBUG
26991  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
26992 #endif
26993  }
26994  if (ret) {
26995  if (type == swig_module.type_initial[i]) {
26996 #ifdef SWIGRUNTIME_DEBUG
26997  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
26998 #endif
26999  cast->type = ret;
27000  ret = 0;
27001  } else {
27002  /* Check for casting already in the list */
27003  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27004 #ifdef SWIGRUNTIME_DEBUG
27005  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27006 #endif
27007  if (!ocast) ret = 0;
27008  }
27009  }
27010 
27011  if (!ret) {
27012 #ifdef SWIGRUNTIME_DEBUG
27013  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27014 #endif
27015  if (type->cast) {
27016  type->cast->prev = cast;
27017  cast->next = type->cast;
27018  }
27019  type->cast = cast;
27020  }
27021  cast++;
27022  }
27023  /* Set entry in modules->types array equal to the type */
27024  swig_module.types[i] = type;
27025  }
27026  swig_module.types[i] = 0;
27027 
27028 #ifdef SWIGRUNTIME_DEBUG
27029  printf("**** SWIG_InitializeModule: Cast List ******\n");
27030  for (i = 0; i < swig_module.size; ++i) {
27031  int j = 0;
27033  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27034  while (cast->type) {
27035  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27036  cast++;
27037  ++j;
27038  }
27039  printf("---- Total casts: %d\n",j);
27040  }
27041  printf("**** SWIG_InitializeModule: Cast List ******\n");
27042 #endif
27043 }
27044 
27045 /* This function will propagate the clientdata field of type to
27046 * any new swig_type_info structures that have been added into the list
27047 * of equivalent types. It is like calling
27048 * SWIG_TypeClientData(type, clientdata) a second time.
27049 */
27050 SWIGRUNTIME void
27052  size_t i;
27053  swig_cast_info *equiv;
27054  static int init_run = 0;
27055 
27056  if (init_run) return;
27057  init_run = 1;
27058 
27059  for (i = 0; i < swig_module.size; i++) {
27060  if (swig_module.types[i]->clientdata) {
27061  equiv = swig_module.types[i]->cast;
27062  while (equiv) {
27063  if (!equiv->converter) {
27064  if (equiv->type && !equiv->type->clientdata)
27066  }
27067  equiv = equiv->next;
27068  }
27069  }
27070  }
27071 }
27072 
27073 #ifdef __cplusplus
27074 #if 0
27075 { /* c-mode */
27076 #endif
27077 }
27078 #endif
27079 
27080 
27081 
27082 static bool SWIG_init_user(octave_swig_type* module_ns);
27083 
27085  bool retn = false;
27086  {
27087 #if SWIG_OCTAVE_PREREQ(4,2,0)
27088  octave::unwind_protect frame;
27089  frame.protect_var(discard_error_messages); discard_error_messages = true;
27090  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27091 #elif SWIG_OCTAVE_PREREQ(3,3,50)
27092  unwind_protect frame;
27093  frame.protect_var(error_state); error_state = 0;
27094  frame.protect_var(warning_state); warning_state = 0;
27095  frame.protect_var(discard_error_messages); discard_error_messages = true;
27096  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27097 #else
27098  unwind_protect::begin_frame("SWIG_Octave_LoadModule");
27099  unwind_protect_int(error_state); error_state = 0;
27100  unwind_protect_int(warning_state); warning_state = 0;
27101  unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27102  unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27103 #endif
27104 #if SWIG_OCTAVE_PREREQ(4,2,0)
27105  try {
27106 #if SWIG_OCTAVE_PREREQ(4,4,0)
27107  octave::feval(name, octave_value_list(), 0);
27108 #else
27109  feval(name, octave_value_list(), 0);
27110 #endif
27111  retn = true;
27112  } catch (octave::execution_exception&) { }
27113 #else
27114  feval(name, octave_value_list(), 0);
27115  retn = (error_state == 0);
27116 #endif
27117 #if !SWIG_OCTAVE_PREREQ(3,3,50)
27118  unwind_protect::run_frame("SWIG_Octave_LoadModule");
27119 #endif
27120  }
27121  if (!retn) {
27122  error(SWIG_name_d ": could not load module `%s'", name.c_str());
27123  }
27124  return retn;
27125 }
27126 
27127 SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
27128  bool retn = false;
27129  {
27130 #if SWIG_OCTAVE_PREREQ(4,2,0)
27131  octave::unwind_protect frame;
27132  frame.protect_var(discard_error_messages); discard_error_messages = true;
27133  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27134 #elif SWIG_OCTAVE_PREREQ(3,3,50)
27135  unwind_protect frame;
27136  frame.protect_var(error_state); error_state = 0;
27137  frame.protect_var(warning_state); warning_state = 0;
27138  frame.protect_var(discard_error_messages); discard_error_messages = true;
27139  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27140 #else
27141  unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
27142  unwind_protect_int(error_state); error_state = 0;
27143  unwind_protect_int(warning_state); warning_state = 0;
27144  unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27145  unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27146 #endif
27147  octave_value_list args;
27148  args.append(name);
27149  args.append(octloadfcn->fcn_file_name());
27150 #if SWIG_OCTAVE_PREREQ(4,2,0)
27151  try {
27152 #if SWIG_OCTAVE_PREREQ(4,4,0)
27153  octave::feval("autoload", args, 0);
27154 #else
27155  feval("autoload", args, 0);
27156 #endif
27157  retn = true;
27158  } catch (octave::execution_exception&) { }
27159 #else
27160  feval("autoload", args, 0);
27161  retn = (error_state == 0);
27162 #endif
27163 #if !SWIG_OCTAVE_PREREQ(3,3,50)
27164  unwind_protect::run_frame("SWIG_Octave_InstallFunction");
27165 #endif
27166  }
27167  if (!retn) {
27168  error(SWIG_name_d ": could not load function `%s'", name.c_str());
27169  }
27170  return retn;
27171 }
27172 
27173 static const char *const subclass_usage = "-*- texinfo -*- \n\
27174 @deftypefn {Loadable Function} {} subclass()\n\
27175 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27176 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27177 \n\
27178 See the SWIG manual for usage examples.\n\
27179 @end deftypefn";
27180 
27181 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
27183  for (int j = 0; j < args.length(); ++j) {
27184  if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27185  octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
27186  octave_swig_type *ost = osr->get_ptr();
27187  if (!ost->is_owned()) {
27188  error("subclass: cannot subclass object not constructed on octave side");
27189  return octave_value_list();
27190  }
27191  top->merge(*ost);
27192  } else if (args(j).is_function_handle()) {
27193  top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27194  } else if (args(j).is_string()) {
27195  if (j + 1 >= args.length()) {
27196  error("subclass: member assignments must be of string,value form");
27197  return octave_value_list();
27198  }
27199  top->assign(args(j).string_value(), args(j + 1));
27200  ++j;
27201  } else {
27202  error("subclass: invalid arguments to subclass()");
27203  return octave_value_list();
27204  }
27205  }
27206  return octave_value(Swig::swig_value_ref(top));
27207 }
27208 
27209 static const char *const swig_type_usage = "-*- texinfo -*- \n\
27210 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27211 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27212 @end deftypefn";
27213 
27214 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
27215  if (args.length() != 1) {
27216  error("swig_type: must be called with only a single object");
27217  return octave_value_list();
27218  }
27219  octave_swig_type *ost = Swig::swig_value_deref(args(0));
27220  if (!ost) {
27221  error("swig_type: object is not a swig_ref");
27222  return octave_value_list();
27223  }
27224  return octave_value(ost->swig_type_name());
27225 }
27226 
27227 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
27228 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27229 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27230 otherwise return `<unknown>'.\n\
27231 @end deftypefn";
27232 
27233 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
27234  if (args.length() != 1 || !args(0).is_string()) {
27235  error("swig_typequery: must be called with single string argument");
27236  return octave_value_list();
27237  }
27239  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
27240  if (!type)
27241  return octave_value("<unknown>");
27242  return octave_value(type->name);
27243 }
27244 
27245 static const char *const swig_this_usage = "-*- texinfo -*- \n\
27246 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27247 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27248 @end deftypefn";
27249 
27251  if (args.length() != 1) {
27252  error("swig_this: must be called with only a single object");
27253  return octave_value_list();
27254  }
27255  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27256  return octave_value(octave_uint64(0));
27257  octave_swig_type *ost = Swig::swig_value_deref(args(0));
27258  if (!ost) {
27259  error("swig_this: object is not a swig_ref");
27260  return octave_value_list();
27261  }
27262  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
27263 }
27264 
27265 static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
27266 @deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27267 Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27268 @end deftypefn";
27269 
27270 DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
27271  if (args.length() != 3) {
27272  error("swig_octave_prereq: must be called with 3 arguments");
27273  return octave_value_list();
27274  }
27275  const int major = args(0).int_value();
27276  const int minor = args(1).int_value();
27277  const int patch = args(2).int_value();
27278  const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
27279  return octave_value(prereq);
27280 }
27281 
27282 static const char *const swig_exit_usage = "-*- texinfo -*- \n\
27283 @deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27284 Exit Octave without performing any memory cleanup.\n\
27285 @end deftypefn";
27286 
27287 DEFUN_DLD( swig_exit, args, nargout, swig_exit_usage ) {
27288  if (args.length() > 1) {
27289  error("swig_exit: must be called with at most one arguments");
27290  return octave_value_list();
27291  }
27292  int exit_status = 0;
27293  if (args.length() == 1) {
27294  exit_status = args(0).int_value();
27295  }
27296  ::_Exit(exit_status);
27297  return octave_value();
27298 }
27299 
27300 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
27301 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27302 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27303 @end deftypefn";
27304 
27306 
27307  static octave_swig_type* module_ns = 0;
27308 
27309  // workaround to prevent octave seg-faulting on exit: set Octave exit function
27310  // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
27311  // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
27312  // version 3.4.*, reappeared in 4.2.*, hack not possible in 4.4.* or later due to
27313  // removal of octave_exit, so turn on for all versions between 3.2.*. and 4.4.*.
27314  // can be turned off with macro definition.
27315 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27316 #if !SWIG_OCTAVE_PREREQ(4,4,0)
27317 #if SWIG_OCTAVE_PREREQ(3,2,0)
27318  octave_exit = ::_Exit;
27319 #endif
27320 #endif
27321 #endif
27322 
27323  // check for no input and output args
27324  if (args.length() != 0 || nargout != 0) {
27325  print_usage();
27326  return octave_value_list();
27327  }
27328 
27329  // create module on first function call
27330  if (!module_ns) {
27331 
27332  // workaround bug in octave where installing global variable of custom type and then
27333  // exiting without explicitly clearing the variable causes octave to segfault.
27334 #if SWIG_OCTAVE_PREREQ(3,2,0)
27335  octave_value_list eval_args;
27336  eval_args.append("base");
27337  eval_args.append("function __swig_atexit__; "
27338  " if mislocked() "
27339  " clear -all; "
27340  " else "
27341  " mlock(); "
27342  " endif; "
27343  "endfunction; "
27344  "__swig_atexit__; "
27345  "atexit(\"__swig_atexit__\", false); "
27346  "atexit(\"__swig_atexit__\")");
27347 #if SWIG_OCTAVE_PREREQ(4,4,0)
27348  octave::feval("evalin", eval_args, 0);
27349 #else
27350  feval("evalin", eval_args, 0);
27351 #endif
27352 #endif
27353 
27354 #if SWIG_OCTAVE_PREREQ(4,4,0)
27355  {
27356  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27357  string_vector types = typeinfo.installed_type_names();
27358  bool register_octave_swig_ref = true;
27359  bool register_octave_swig_packed = true;
27360  for (int i = 0; i < types.numel(); ++i) {
27361  if (types(i) == octave_swig_ref::static_type_name()) {
27362  register_octave_swig_ref = false;
27363  }
27364  if (types(i) == octave_swig_packed::static_type_name()) {
27365  register_octave_swig_packed = false;
27366  }
27367  }
27368  if (register_octave_swig_ref) {
27369  octave_swig_ref::register_type();
27370  }
27371  if (register_octave_swig_packed) {
27372  octave_swig_packed::register_type();
27373  }
27374  }
27375 #else
27376  octave_swig_ref::register_type();
27377  octave_swig_packed::register_type();
27378 #endif
27381 
27382 #if SWIG_OCTAVE_PREREQ(4,4,0)
27383  octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27384  octave_function *me = stack.current();
27385 #else
27386  octave_function *me = octave_call_stack::current();
27387 #endif
27388 
27389  if (!SWIG_Octave_InstallFunction(me, "subclass")) {
27390  return octave_value_list();
27391  }
27392  if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
27393  return octave_value_list();
27394  }
27395  if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
27396  return octave_value_list();
27397  }
27398  if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
27399  return octave_value_list();
27400  }
27401  if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
27402  return octave_value_list();
27403  }
27404  if (!SWIG_Octave_InstallFunction(me, "swig_exit")) {
27405  return octave_value_list();
27406  }
27407 
27408  octave_swig_type* cvar_ns=0;
27409  if (std::string(SWIG_global_name) != ".") {
27410  cvar_ns=new octave_swig_type;
27411  for (int j=0;swig_globals[j].name;++j)
27412  if (swig_globals[j].get_method)
27413  cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
27414  }
27415 
27416  module_ns=new octave_swig_type(0, 0, 0, true);
27417  if (std::string(SWIG_global_name) != ".") {
27418  module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
27419  }
27420  else {
27421  for (int j=0;swig_globals[j].name;++j)
27422  if (swig_globals[j].get_method)
27423  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27424  }
27425  for (int j=0;swig_globals[j].name;++j)
27426  if (swig_globals[j].method)
27427  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27428 
27429  // * need better solution here; swig_type -> octave_class mapping is
27430  // * really n-to-1, in some cases such as template partial spec, etc.
27431  // * see failing tests.
27432  for (int j=0;swig_types[j];++j)
27433  if (swig_types[j]->clientdata) {
27434  swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
27435  module_ns->assign(c->name,
27437  (new octave_swig_type(0,swig_types[j])));
27438  }
27439 
27440  if (!SWIG_init_user(module_ns)) {
27441  delete module_ns;
27442  module_ns=0;
27443  return octave_value_list();
27444  }
27445 
27446  SWIG_InstallOps(octave_swig_ref::static_type_id());
27447 
27449  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27450  if (mb->second.first && mb->second.first->method) {
27451  if (!SWIG_Octave_InstallFunction(me, mb->first)) {
27452  return octave_value_list();
27453  }
27454  }
27455  }
27456 
27457 #if SWIG_OCTAVE_PREREQ(4,4,0)
27458  octave::interpreter::the_interpreter()->mlock();
27459 #elif SWIG_OCTAVE_PREREQ(3,2,0)
27460  mlock();
27461 #else
27462  mlock(me->name());
27463 #endif
27464 
27465  }
27466 
27468  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27469  if (mb->second.second.is_defined()) {
27470  SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
27471  SWIG_Octave_LinkGlobalValue(mb->first);
27472  }
27473  }
27474 
27477 
27478  return octave_value_list();
27479 
27480 }
27481 
27482 
27483 static bool SWIG_init_user(octave_swig_type* module_ns)
27484 {
27485  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
27486  SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
27487  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
27488  SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
27489  SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
27490  SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
27491  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
27492  SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
27493  SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
27494  SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
27495  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
27496  SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
27497  SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
27498  SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
27499  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
27500  SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
27501  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
27502  SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
27503  SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
27504  SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
27505  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
27506  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
27507  SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
27508  SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
27509  SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
27510  SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
27511  SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
27512  SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
27513  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
27514  SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
27515  SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
27516  SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
27517  SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
27518  SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
27519  SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
27520  SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
27521  SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
27522  SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
27523  SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
27524  SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
27525  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
27526  SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
27527  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
27528  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
27529  SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
27530  SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
27531  SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
27532  SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
27533  SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
27534  SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
27535  SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
27536  SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
27537  SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
27538  SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
27539  SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
27540  SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
27541  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
27542  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
27543  SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27544  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
27545  SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
27546  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
27547  SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
27548  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
27549  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
27550  SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
27551  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
27552  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
27553  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
27554  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27555  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
27556  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
27557  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
27558  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
27559  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
27560  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
27561  SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
27562  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
27563  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
27564  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
27565  SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
27566  SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
27567  SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
27568  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
27569  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
27570  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
27571  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
27572  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
27573  SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
27574  SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
27575  SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
27576  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
27577  SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
27578  SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
27579  SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
27580  SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
27581  SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
27582  SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
27583  SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
27584  SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
27585  SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
27586  SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
27587  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
27588  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
27589  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
27590  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
27591  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
27592  SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
27593  SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
27594  SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
27595  SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
27596  SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
27597  SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
27598  SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
27599  SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
27600  SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
27601  SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
27602  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
27603  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
27604  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
27605  SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
27606  SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
27607  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
27608  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
27609  SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
27610  SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
27611  SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
27612  SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
27613  SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
27614  SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
27615  SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
27616  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
27617  SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
27618  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
27619  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
27620  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
27621  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27622  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27623  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
27624  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27625  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
27626  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
27627  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
27628  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
27629  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
27630  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
27631  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
27632  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
27633  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
27634  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
27635  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
27636  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
27637  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
27638  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
27639  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27640  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27641  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
27642  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27643  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
27644  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
27645  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
27646  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
27647  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
27648  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
27649  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
27650  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
27651  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
27652  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
27653  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
27654  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
27655  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
27656  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
27657  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
27658  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
27659  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
27660  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
27661  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
27662  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
27663  SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
27664  SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
27665  SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
27666  SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
27667  SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
27668  SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
27669  SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
27670  return true;
27671 }
27672 
octave_base_value * clone() const
virtual bool load_ascii(std::istream &is)
octave_base_value * empty_clone() const
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
octave_swig_packed(swig_type_info *_type=0, const void *_buf=0, size_t _buf_len=0)
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
virtual bool save_ascii(std::ostream &os)
virtual string_vector map_keys() const
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
virtual double scalar_value(bool frc_str_conv=false) const
virtual bool is_object() const
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
virtual bool save_ascii(std::ostream &os)
dim_vector dims(void) const
virtual Octave_map map_value() const
virtual bool is_map() const
virtual bool is_string() const
virtual std::string string_value(bool force=false) const
octave_base_value * empty_clone() const
octave_base_value * clone() const
virtual type_conv_info numeric_conversion_function(void) const
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
static octave_base_value * default_numeric_conversion_function(const octave_base_value &a)
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
void print(std::ostream &os, bool pr_as_read_syntax=false) const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
octave_swig_type * get_ptr() const
octave_swig_ref(octave_swig_type *_ptr=0)
virtual bool load_ascii(std::istream &is)
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
void load_members(member_map &out) const
virtual Octave_map map_value() const
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name)
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
octave_swig_type(const octave_swig_type &x)
octave_base_value * clone() const
swig_member_const_iterator swig_members_begin()
std::map< std::string, member_value_pair > member_map
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
virtual bool save_ascii(std::ostream &os)
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
swig_member_const_iterator swig_members_end()
dim_vector dims(void) const
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const
octave_base_value * empty_clone() const
virtual bool load_ascii(std::istream &is)
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
virtual bool is_object() const
void assign(const std::string &name, const swig_octave_member *m)
const swig_octave_member * find_member(const swig_type_info *type, const std::string &name)
const char * help_text() const
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
virtual string_vector map_keys() const
void assign(const std::string &name, const octave_value &ov)
virtual bool is_string() const
static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret)
std::vector< type_ptr_pair > types
virtual double scalar_value(bool frc_str_conv=false) const
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
virtual std::string string_value(bool force=false) const
static octave_value make_value_hack(const octave_base_value &x)
void load_members(const swig_octave_class *c, member_map &out) const
octave_swig_type & operator=(const octave_swig_type &rhs)
std::string swig_type_name() const
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const
std::pair< const swig_octave_member *, octave_value > member_value_pair
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
void merge(octave_swig_type &rhs)
member_map::const_iterator swig_member_const_iterator
void print(std::ostream &os, bool pr_as_read_syntax=false) const
int cast(void **vptr, swig_type_info *type, int *_own, int flags)
const swig_type_info * construct_type
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
virtual bool is_map() const
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
SWIGRUNTIME octave_swig_type * swig_value_deref(const octave_base_value &ov)
integer(kind=private_plint), parameter, private maxlen
Definition: plplot.f90:48
alias _N2 PLGraphicsIn
Definition: plplot.d:1262
void plOptUsage(void)
Definition: plargs.c:1304
void plClearOpts(void)
Definition: plargs.c:830
void plResetOpts(void)
Definition: plargs.c:843
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition: plargs.c:1287
static int error
Definition: plcont.c:61
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:941
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
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:874
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition: plcont.c:858
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1219
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 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
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
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
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
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
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
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
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
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
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
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
Definition: plot3d.c:118
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_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
PLINT plTranslateCursor(PLGraphicsIn *plg)
Definition: plpage.c:259
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
#define plgfci
Definition: plplot.h:735
#define plgstrm
Definition: plplot.h:744
#define plpat
Definition: plplot.h:779
#define plschr
Definition: plplot.h:790
#define plfontld
Definition: plplot.h:721
#define plpath
Definition: plplot.h:761
#define plerry
Definition: plplot.h:715
#define plsfam
Definition: plplot.h:816
#define plsmaj
Definition: plplot.h:826
#define plsmin
Definition: plplot.h:829
#define pleop
Definition: plplot.h:713
#define plimage
Definition: plplot.h:753
#define plstransform
Definition: plplot.h:840
#define plfill
Definition: plplot.h:717
#define plvpas
Definition: plplot.h:859
#define plgdiplt
Definition: plplot.h:732
#define plerrx
Definition: plplot.h:714
#define plinit
Definition: plplot.h:755
#define plscmap1l
Definition: plplot.h:796
#define plsori
Definition: plplot.h:830
#define plbox3
Definition: plplot.h:698
#define plcol1
Definition: plplot.h:703
#define pltimefmt
Definition: plplot.h:856
PLUINT PLUNICODE
Definition: plplot.h:201
#define plvect
Definition: plplot.h:858
#define plgchr
Definition: plplot.h:722
float PLFLT
Definition: plplot.h:163
#define pllegend
Definition: plplot.h:758
#define plsyax
Definition: plplot.h:852
#define plgver
Definition: plplot.h:745
#define plscolbg
Definition: plplot.h:802
#define plpsty
Definition: plplot.h:784
#define plgfont
Definition: plplot.h:737
#define plenv
Definition: plplot.h:711
#define pllightsource
Definition: plplot.h:759
#define plpoin3
Definition: plplot.h:781
#define plgspa
Definition: plplot.h:743
#define plscol0
Definition: plplot.h:800
#define plptex
Definition: plplot.h:785
#define plrgbhls
Definition: plplot.h:789
#define plbop
Definition: plplot.h:696
#define plgdidev
Definition: plplot.h:730
#define plpoin
Definition: plplot.h:780
#define plptex3
Definition: plplot.h:786
#define plstripd
Definition: plplot.h:845
#define plhist
Definition: plplot.h:751
#define plgfnam
Definition: plplot.h:736
#define plgdiori
Definition: plplot.h:731
#define PL_MAXKEY
Definition: plplot.h:408
#define plszax
Definition: plplot.h:854
#define plstripa
Definition: plplot.h:843
#define plgxax
Definition: plplot.h:748
#define plgra
Definition: plplot.h:740
#define plenv0
Definition: plplot.h:712
#define plspal1
Definition: plplot.h:833
#define plstring3
Definition: plplot.h:842
#define plxormod
Definition: plplot.h:865
#define plspause
Definition: plplot.h:834
#define plgdev
Definition: plplot.h:729
#define plgradient
Definition: plplot.h:741
#define plspal0
Definition: plplot.h:832
#define plcalc_world
Definition: plplot.h:700
#define plwidth
Definition: plplot.h:863
#define pllab
Definition: plplot.h:757
#define plsurf3d
Definition: plplot.h:847
#define plsurf3dl
Definition: plplot.h:848
#define plvasp
Definition: plplot.h:857
#define plscmap0n
Definition: plplot.h:793
#define plmtex3
Definition: plplot.h:774
#define plctime
Definition: plplot.h:708
#define plclear
Definition: plplot.h:701
#define plsvpa
Definition: plplot.h:850
#define plw3d
Definition: plplot.h:862
#define plot3dcl
Definition: plplot.h:777
#define plscmap1n
Definition: plplot.h:798
#define plgvpd
Definition: plplot.h:746
#define plhlsrgb
Definition: plplot.h:752
#define pl_setcontlabelformat
Definition: plplot.h:690
#define plsdev
Definition: plplot.h:806
#define plconfigtime
Definition: plplot.h:705
#define plscolbga
Definition: plplot.h:803
#define plscmap1
Definition: plplot.h:794
#define plsdiplz
Definition: plplot.h:811
#define plparseopts
Definition: plplot.h:778
#define plot3d
Definition: plplot.h:775
#define plsesc
Definition: plplot.h:814
#define plarc
Definition: plplot.h:693
#define plsetopt
Definition: plplot.h:815
#define plgvpw
Definition: plplot.h:747
#define pltext
Definition: plplot.h:855
#define plstring
Definition: plplot.h:841
#define plsdiori
Definition: plplot.h:809
#define plcont
Definition: plplot.h:706
#define plspage
Definition: plplot.h:831
#define plaxes
Definition: plplot.h:694
#define pllsty
Definition: plplot.h:763
#define plslabelfunc
Definition: plplot.h:825
#define plshades
Definition: plplot.h:824
#define plglevel
Definition: plplot.h:738
#define plscompression
Definition: plplot.h:805
#define plfamadv
Definition: plplot.h:716
#define plfont
Definition: plplot.h:720
#define plscmap0a
Definition: plplot.h:792
#define plgcol0a
Definition: plplot.h:725
#define plscmap1_range
Definition: plplot.h:799
#define plmeshc
Definition: plplot.h:771
#define plshade
Definition: plplot.h:820
#define plsym
Definition: plplot.h:853
#define plscmap1a
Definition: plplot.h:795
#define plscmap0
Definition: plplot.h:791
#define plgriddata
Definition: plplot.h:742
#define plstripc
Definition: plplot.h:844
#define pl_setcontlabelparam
Definition: plplot.h:691
#define plsvect
Definition: plplot.h:849
#define plstyl
Definition: plplot.h:846
#define plline
Definition: plplot.h:760
#define pljoin
Definition: plplot.h:756
#define plgzax
Definition: plplot.h:750
#define plsstrm
Definition: plplot.h:835
#define plscmap1la
Definition: plplot.h:797
#define plssym
Definition: plplot.h:837
#define plscolor
Definition: plplot.h:804
#define plcol0
Definition: plplot.h:702
#define plsdiplt
Definition: plplot.h:810
#define plcolorbar
Definition: plplot.h:704
#define plvsta
Definition: plplot.h:861
#define plot3dc
Definition: plplot.h:776
#define plcpstrm
Definition: plplot.h:707
#define plmkstrm
Definition: plplot.h:772
#define plgcol0
Definition: plplot.h:724
#define pladv
Definition: plplot.h:692
#define plgcolbga
Definition: plplot.h:727
#define plline3
Definition: plplot.h:762
#define plprec
Definition: plplot.h:783
#define plfill3
Definition: plplot.h:718
#define plseed
Definition: plplot.h:813
#define plgcompression
Definition: plplot.h:728
#define plimagefr
Definition: plplot.h:754
#define plsfont
Definition: plplot.h:819
int PLINT
Definition: plplot.h:181
#define plgfam
Definition: plplot.h:734
#define plscol0a
Definition: plplot.h:801
#define plend1
Definition: plplot.h:710
#define plrandd
Definition: plplot.h:787
#define plbin
Definition: plplot.h:695
#define plsdidev
Definition: plplot.h:807
#define plsfnam
Definition: plplot.h:818
void * PLPointer
Definition: plplot.h:209
#define plflush
Definition: plplot.h:719
#define plwind
Definition: plplot.h:864
#define plstar
Definition: plplot.h:838
#define plmtex
Definition: plplot.h:773
PLINT PLBOOL
Definition: plplot.h:204
#define plsdimap
Definition: plplot.h:808
#define plsfci
Definition: plplot.h:817
#define plend
Definition: plplot.h:709
#define plmesh
Definition: plplot.h:770
#define plreplot
Definition: plplot.h:788
#define plgcolbg
Definition: plplot.h:726
#define plgcmap1_range
Definition: plplot.h:723
#define plstart
Definition: plplot.h:839
#define plsxax
Definition: plplot.h:851
#define plbox
Definition: plplot.h:697
#define plbtime
Definition: plplot.h:699
#define plgyax
Definition: plplot.h:749
#define plvpor
Definition: plplot.h:860
#define plpoly3
Definition: plplot.h:782
#define plgpage
Definition: plplot.h:739
#define plssub
Definition: plplot.h:836
void my_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
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_plszax_texinfo
static const char * _wrap_plstring3_texinfo
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
static const char * _wrap_plvsta_texinfo
static const char * _wrap_plscmap1_texinfo
static const char * _wrap_plbox3_texinfo
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)
static const char * _wrap_plmeshc_texinfo
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
static swig_cast_info * swig_cast_initial[]
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)
static const char * _wrap_plvpas_texinfo
static const char * _wrap_pladv_texinfo
static const char * _wrap_plcalc_world_texinfo
static const char * _wrap_plmkstrm_texinfo
#define SWIG_global_name
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
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 swig_type_info * swig_types[10]
void my_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
static const char * _wrap_pltimefmt_texinfo
static const char * _wrap_plend_texinfo
static const swig_type_info * swig_PLGraphicsIn_base[]
static const char * _wrap_plsvpa_texinfo
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
octave_function * fcnCoordTrans
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
static const char * _wrap_plgdev_texinfo
static const char * _wrap_plcol0_texinfo
static const char * _wrap_plfamadv_texinfo
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
#define SWIG_TypeQuery(name)
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
#define SWIG_POINTER_OWN
static const char * _wrap_plmeridians_texinfo
static const char * _wrap_plsdidev_texinfo
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
#define SWIG_SyntaxError
static const char * _wrap_plflush_texinfo
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
static const char * _wrap_plsfnam_texinfo
#define SWIG_CheckState(r)
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
#define f2c(f, ff, nx, ny)
static const char * _wrap_plot3dc_texinfo
static const char * _wrap_plptex_texinfo
static swig_cast_info _swigc__p_int[]
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
static const char * _wrap_plbin_texinfo
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
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)
static const char * _wrap_plsmaj_texinfo
#define SWIG_TypeError
static const char * _wrap_plsstrm_texinfo
static PLINT Alen
static swig_cast_info _swigc__p_double[]
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
#define SWIGTYPE_p_PLGraphicsIn
static const char * _wrap_plgcompression_texinfo
static const char * _wrap_plscolor_texinfo
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)
struct swig_cast_info swig_cast_info
static const char * _wrap_plfill_texinfo
static const struct swig_octave_member swig_globals[]
static const char * _wrap_pllightsource_texinfo
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
static const char * _wrap_plscmap0_texinfo
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
static const char *const swig_typequery_usage
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
std::string nameCoordTrans
static const char * _wrap_plgcol0a_texinfo
static const char * _wrap_plSetOpt_texinfo
#define SWIG_RuntimeError
static const char * _wrap_plgcmap1_range_texinfo
static const char * _wrap_plarc_texinfo
SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
static const char * _wrap_plend1_texinfo
static const char * _wrap_plgcolbga_texinfo
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)
static const char * _wrap_plprec_texinfo
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
static const char *const SWIG_name_usage
static const char * _wrap_plgpage_texinfo
static const char * _wrap_plschr_texinfo
static int _arraylen(const octave_value &o_obj)
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
#define swig_unary_op(name)
static const char * _wrap_plsdiori_texinfo
SWIGINTERNINLINE octave_value SWIG_From_double(double value)
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
#define SWIGRUNTIME
static const char * _wrap_plsurf3d_texinfo
#define SWIG_OCTAVE_PREREQ(major, minor, patch)
static const char * _wrap_plgfnam_texinfo
static const char * _wrap_plenv0_texinfo
#define swigreg_binary_op(name)
static const char * _wrap_plenv_texinfo
#define SWIG_as_voidptrptr(a)
static const char * _wrap_plsym_texinfo
static const char * _wrap_plmapstring_texinfo
#define SWIG_RUNTIME_VERSION
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)
#define SWIG_OLDOBJ
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
static const char * _wrap_plslabelfunc_texinfo
#define SWIG_ValueError
static const char * _wrap_plsfci_texinfo
static const char * _wrap_plgchr_texinfo
#define SWIG_AddCast(r)
static const char * _wrap_plstripd_texinfo
static const char * _wrap_plsori_texinfo
static const char * _wrap_plsdiplt_texinfo
#define SWIG_name_d
#define SWIG_IsNewObj(r)
static const char * _wrap_plsfam_texinfo
static const char * _wrap_plgver_texinfo
static const char * _wrap_plstransform_texinfo
SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov)
std::string nameMapForm
#define SWIG_exception_fail(code, msg)
#define SWIG_OCTAVE_BOUND_FUNC(func, args)
static const char * _wrap_plgdiori_texinfo
static const char * _wrap_plbtime_texinfo
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
#define SWIG_AttributeError
static const char * _wrap_plstripc_texinfo
static const char * _wrap_plgfam_texinfo
static const char * _wrap_plseed_texinfo
static const char * _wrap_plerrx_texinfo
static swig_module_info swig_module
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
static int _n_dims(const octave_value &o_obj)
static const char * _wrap_plot3d_texinfo
static const char * _wrap_plmtex_texinfo
static const char * _wrap_plmap_texinfo
#define swigreg_unary_op(name)
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
static const char * swig_PLGraphicsIn_base_names[]
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
static const char * _wrap_plrgbhls_texinfo
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
static const char * _wrap_plrandd_texinfo
static const char * _wrap_plmesh_texinfo
static const char * _wrap_plsurf3dl_texinfo
static PLINT Ylen
static swig_type_info _swigt__p_double
static const char * _wrap_plmapfill_texinfo
static const char * _wrap_plaxes_texinfo
static const char * _wrap_plscmap0n_texinfo
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref")
static const char * _wrap_plsesc_texinfo
#define SWIG_SetModule(clientdata, pointer)
static const char * _wrap_plgvpw_texinfo
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
static const char * _wrap_plgfont_texinfo
static const char * _wrap_plshades_texinfo
static const char * _wrap_plscmap1n_texinfo
static const char * _wrap_plstyl_texinfo
static const char * _wrap_plwind_texinfo
#define SWIG_as_voidptr(a)
void my_plcont0(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel)
static const char * _wrap_plsdiplz_texinfo
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static swig_type_info _swigt__p_p_char
static const char * _wrap_pllsty_texinfo
static const char *const subclass_usage
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
SWIGINTERN int SWIG_AsVal_char(octave_value obj, char *val)
static const char * _wrap_plgstrm_texinfo
static const char * _wrap_plconfigtime_texinfo
static const char * _wrap_plssub_texinfo
#define SWIG_ConvertPtr(obj, pptr, type, flags)
static const char * _wrap_plgzax_texinfo
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
#define SWIGTYPE_p_int
static const char * _wrap_plline_texinfo
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 const char *const swig_type_usage
static const char * _wrap_plshade_texinfo
static const char * _wrap_pl_setcontlabelformat_texinfo
static const char *const swig_exit_usage
static const char * _wrap_plsdev_texinfo
static const char * _wrap_plgxax_texinfo
static const char * _wrap_plinit_texinfo
static const char * _wrap_plpoin3_texinfo
static const char * _wrap_plfontld_texinfo
static const char * _wrap_plpsty_texinfo
static const char * _wrap_plmapline_texinfo
std::string nameLabelFunc
static const char * _wrap_plscompression_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
static const char * _wrap_plstart_texinfo
static const char * _wrap_plscol0_texinfo
void my_plvect2(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
#define SWIG_DEFUN(cname, wname, doc)
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
static const char * _wrap_plgdiplt_texinfo
static const char * _wrap_plcpstrm_texinfo
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
static const char * _wrap_plvect_texinfo
void my_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char **label, PLINT n_axes, const char **axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT *a)
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
static swig_cast_info _swigc__p_char[]
static const char * _wrap_plscolbga_texinfo
static const char * _wrap_plscol0a_texinfo
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
octave_value_list(* octave_func)(const octave_value_list &, int)
static const char * _wrap_plscmap1a_texinfo
SWIGINTERNINLINE octave_value SWIG_FromCharPtrAndSize(const char *carray, size_t size)
#define SWIGINTERN
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)
static int _dim(const octave_value &o_obj, int dim_idx)
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
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)
#define SWIG_op_prefix
static const char * _wrap_plgcol0_texinfo
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static const char * _wrap_plstar_texinfo
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
#define SWIG_ArgError(r)
#define SWIG_NewPointerObj(ptr, type, flags)
static const char * _wrap_plsmin_texinfo
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
static const char * _wrap_plglevel_texinfo
static const char * _wrap_plvpor_texinfo
void *(* swig_converter_func)(void *, int *)
#define SWIG_POINTER_NO_NULL
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)
SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer)
octave_function * fcnLabelFunc
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
static const char * _wrap_plgfci_texinfo
#define SWIG_IOError
static const char * _wrap_plsfont_texinfo
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
static const char * _wrap_pllegend_texinfo
#define SWIG_NullReferenceError
static const char * _wrap_plhlsrgb_texinfo
static const char * _wrap_plgvpd_texinfo
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
static const char * _wrap_plsxax_texinfo
static const char * _wrap_plmtex3_texinfo
#define SWIG_POINTER_DISOWN
struct swig_type_info swig_type_info
static swig_type_info _swigt__p_PLGraphicsIn
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
#define SWIG_IsTmpObj(r)
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)
static const char *const swig_octave_prereq_usage
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)
static const char * _wrap_plscmap1l_texinfo
#define SWIG_NEWOBJ
static swig_octave_class _wrap_class_PLGraphicsIn
static const char * _wrap_plfill3_texinfo
static const char * _wrap_plptex3_texinfo
#define SWIG_TMPOBJ
octave_function * fcnMapForm
#define SWIG_DelNewMask(r)
static const char * _wrap_pleop_texinfo
static const char * _wrap_pltext_texinfo
static const char * _wrap_plgyax_texinfo
static const char * _wrap_plbox_texinfo
#define SWIG_GetModule(clientdata)
static const char * _wrap_pllab_texinfo
static swig_cast_info _swigc__p_unsigned_int[]
#define SWIG_fail
static swig_type_info _swigt__p_int
static const char * _wrap_plspage_texinfo
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)
SWIGRUNTIME void SWIG_PropagateClientData(void)
static const char * _wrap_plsyax_texinfo
static const char * _wrap_plsdimap_texinfo
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
static const char * _wrap_plpoin_texinfo
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
int min(int a, int b)
static const char * _wrap_plspause_texinfo
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
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_plgriddata_texinfo
DEFUN_DLD(subclass, args, nargout, subclass_usage)
static const char * _wrap_plspal0_texinfo
SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs)
static const char * _wrap_plclear_texinfo
#define SWIG_TYPE_TABLE_NAME
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
static swig_type_info _swigt__p_unsigned_int
#define SWIG_CAST_NEW_MEMORY
static PLINT Xlen
static swig_type_info _swigt__p_f_int_p_double_p_double__void
#define SWIGTYPE_p_unsigned_int
SWIGRUNTIME octave_value SWIG_ErrorType(int code)
struct swig_module_info swig_module_info
static const char * _wrap_plxormod_texinfo
static const char * _wrap_plpath_texinfo
static const char * _wrap_plimagefr_texinfo
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
#define SWIG_ERROR
#define SWIG_name
static const char * _wrap_pljoin_texinfo
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
static const char * _wrap_plwidth_texinfo
static const char * _wrap_plfont_texinfo
static const char * _wrap_plstripa_texinfo
static swig_octave_member swig_PLGraphicsIn_members[]
static const char * _wrap_plot3dcl_texinfo
static const char * _wrap_plparseopts_texinfo
static const char * _wrap_plgcolbg_texinfo
static swig_type_info * swig_type_initial[]
static const char * _wrap_plgspa_texinfo
static const char * _wrap_plpat_texinfo
static const char * _wrap_plline3_texinfo
#define swig_binary_op(name)
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
static const char * _wrap_plmaptex_texinfo
static swig_cast_info _swigc__p_PLGraphicsIn[]
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)
static const char * _wrap_plstring_texinfo
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
static const char * _wrap_plgdidev_texinfo
static const char *const swig_this_usage
static swig_cast_info _swigc__p_p_char[]
static const char * _wrap_plpoly3_texinfo
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)
#define SWIG_MemoryError
static int my_plTranslateCursor(PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in)
static const char * _wrap_plvasp_texinfo
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
SWIGRUNTIME void SWIG_InstallOps(int tid)
void mapform_octave(PLINT n, PLFLT *x, PLFLT *y)
static const char * _wrap_plw3d_texinfo
#define SWIG_SystemError
#define SWIG_DivisionByZero
static const char * _wrap_plscmap1la_texinfo
static const char * _wrap_plbop_texinfo
#define SWIGTYPE_p_double
#define SWIGTYPE_p_p_char
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)
static swig_type_info _swigt__p_char
void ct_octave(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
static const char * _wrap_plssym_texinfo
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)
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type)
#define SWIG_OverflowError
static const char * _wrap_plgra_texinfo
static const char * _wrap_plhist_texinfo
#define SWIG_IsOK(r)
static const char * _wrap_plspal1_texinfo
static const char * _wrap_plscmap0a_texinfo
static const char * _wrap_plcont_texinfo
static const char * _wrap_plctime_texinfo
static const char * _wrap_plscolbg_texinfo
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)
struct swig_type_info *(* swig_dycast_func)(void **)
static const char * _wrap_plcol1_texinfo
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)
int max(int a, int b)
#define SWIG_IndexError
SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg)
PLINT(* defined_func)(PLFLT, PLFLT)
static bool SWIG_init_user(octave_swig_type *module_ns)
static const char * _wrap_plreplot_texinfo
static const char * _wrap_plsvect_texinfo
static const char * _wrap_plerry_texinfo
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
#define SWIG_OK
static const char * _wrap_plcolorbar_texinfo
void my_plmeshc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
#define SWIGINTERNINLINE
static const char * _wrap_plgradient_texinfo
static const char * _wrap_plGetCursor_texinfo
static const char * _wrap_plscmap1_range_texinfo
#define SWIGRUNTIMEINLINE
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_int(unsigned int value)
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
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
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
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
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 int text
Definition: ps.c:77
char string[PL_MAXKEY]
Definition: plplot.h:440
PLFLT wX
Definition: plplot.h:443
PLFLT wY
Definition: plplot.h:443
PLINT subwindow
Definition: plplot.h:439
PLFLT dY
Definition: plplot.h:442
unsigned int state
Definition: plplot.h:436
unsigned int keysym
Definition: plplot.h:437
PLFLT dX
Definition: plplot.h:442
unsigned int button
Definition: plplot.h:438
PLINT nx
Definition: plplot.h:521
PLFLT_NC_MATRIX xg
Definition: plplot.h:520
PLINT ny
Definition: plplot.h:521
PLFLT_NC_MATRIX yg
Definition: plplot.h:520
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:508
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:508
PLINT nx
Definition: plplot.h:509
PLINT ny
Definition: plplot.h:509
octave_value operator*() const
const octave_value_list & ovl
octave_value_ref(const octave_value_list &_ovl, int _j)
swig_type_info * type
struct swig_cast_info * prev
struct swig_cast_info * next
swig_converter_func converter
swig_type_info ** types
swig_cast_info ** cast_initial
swig_type_info ** type_initial
struct swig_module_info * next
const swig_octave_member * members
const swig_type_info ** base
swig_dycast_func dcast
struct swig_cast_info * cast
static char buf[200]
Definition: tclAPI.c:873
static const char * name
Definition: tkMain.c:135