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 #if SWIG_OCTAVE_PREREQ(6,0,0)
1066  octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1067  return execute(tw,nargout,args);
1068  }
1069 #endif
1070 #if SWIG_OCTAVE_PREREQ(6,0,0)
1071  octave_value_list execute(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1072 #else
1073  octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1074 #endif
1075  octave_value_list all_args;
1076  all_args.append(first_args);
1077  all_args.append(args);
1078  return method->call(tw, nargout, all_args);
1079  }
1080 
1081  octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1082  octave_value_list ovl = subsref(ops, idx, 1);
1083  return ovl.length() ? ovl(0) : octave_value();
1084  }
1085 
1086  octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1087  assert(ops.size() > 0);
1088  assert(ops.size() == idx.size());
1089  if (ops != "(")
1090  error("invalid function call");
1091  octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1092  return call(tw, nargout, *idx.begin());
1093  }
1094 
1095  protected:
1096 
1097  octave_function* method;
1098  octave_value_list first_args;
1099 
1100  std::set<std::string> dispatch_classes;
1101 
1102  };
1103 #else
1104 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1105 #endif
1106 
1107  // octave_swig_type plays the role of both the shadow class and the class
1108  // representation within Octave, since there is no support for classes.
1109  //
1110  // These should really be decoupled, with the class support added to Octave
1111  // and the shadow class given by an m-file script. That would dramatically
1112  // reduce the runtime complexity, and be more in line w/ other modules.
1113 
1114  class octave_swig_type:public octave_base_value {
1115  struct cpp_ptr {
1116  void *ptr;
1118  cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1119  }};
1120  typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1121 
1123 
1124  const swig_type_info *construct_type; // type of special type object
1125  std::vector < type_ptr_pair > types; // our c++ base classes
1126  int own; // whether we call c++ destructors when we die
1127 
1128  typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1129  typedef std::map < std::string, member_value_pair > member_map;
1132 
1133  const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
1134  if (!type->clientdata)
1135  return 0;
1137  const swig_octave_member *m;
1138  for (m = c->members; m->name; ++m)
1139  if (m->name == name)
1140  return m;
1141  for (int j = 0; c->base_names[j]; ++j) {
1142  if (!c->base[j]) {
1143  if (!module)
1144  module = SWIG_GetModule(0);
1145  assert(module);
1146  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1147  }
1148  if (!c->base[j])
1149  return 0;
1150  if ((m = find_member(c->base[j], name)))
1151  return m;
1152  }
1153  return 0;
1154  }
1155 
1156  member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1157  member_map::iterator it = members.find(name);
1158  if (it != members.end())
1159  return &it->second;
1160  const swig_octave_member *m;
1161  for (unsigned int j = 0; j < types.size(); ++j)
1162  if ((m = find_member(types[j].first, name)))
1163  return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1164  if (!insert_if_not_found)
1165  return 0;
1166  return &members[name];
1167  }
1168 
1169  const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
1170  if (!base) {
1171  for (unsigned int j = 0; j < types.size(); ++j) {
1172  assert(types[j].first->clientdata);
1173  swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1174  if (cj->name == name)
1175  return types[j].first;
1176  }
1177  return 0;
1178  }
1179  assert(base->clientdata);
1181  for (int j = 0; c->base_names[j]; ++j) {
1182  if (!c->base[j]) {
1183  if (!module)
1184  module = SWIG_GetModule(0);
1185  assert(module);
1186  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1187  }
1188  if (!c->base[j])
1189  return 0;
1190  assert(c->base[j]->clientdata);
1192  if (cj->name == name)
1193  return c->base[j];
1194  }
1195  return 0;
1196  }
1197 
1198  void load_members(const swig_octave_class* c,member_map& out) const {
1199  for (const swig_octave_member *m = c->members; m->name; ++m) {
1200  if (out.find(m->name) == out.end())
1201  out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1202  }
1203  for (int j = 0; c->base_names[j]; ++j) {
1204  if (!c->base[j]) {
1205  if (!module)
1206  module = SWIG_GetModule(0);
1207  assert(module);
1208  c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1209  }
1210  if (!c->base[j])
1211  continue;
1212  assert(c->base[j]->clientdata);
1213  const swig_octave_class *cj =
1214  (const swig_octave_class *) c->base[j]->clientdata;
1215  load_members(cj,out);
1216  }
1217  }
1218 
1219  void load_members(member_map& out) const {
1220  out=members;
1221  for (unsigned int j = 0; j < types.size(); ++j)
1222  if (types[j].first->clientdata)
1223  load_members((const swig_octave_class *) types[j].first->clientdata, out);
1224  }
1225 
1226  octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1227  if (m->second.is_defined())
1228  return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1229  else if (m->first && m->first->method)
1230  return m->first->method(args, nargout);
1231  error("member not defined or not invocable");
1232  return octave_value_list();
1233  }
1234 
1235  bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
1236  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1237  member_value_pair *m = nc_this->find_member(symbol, false);
1238  if (!m || m->first->is_static() || m->first->is_global())
1239  return false;
1240  octave_value_list args;
1241  args.append(nc_this->as_value());
1242  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1243  if (argout.length() < 1)
1244  return false;
1245  ret = argout(0);
1246  return true;
1247  }
1248 
1249  bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
1250  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1251  member_value_pair *m = nc_this->find_member(symbol, false);
1252  if (!m || m->first->is_static() || m->first->is_global())
1253  return false;
1254  octave_value_list args;
1255  args.append(nc_this->as_value());
1256  args.append(make_value_hack(rhs));
1257  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1258  if (argout.length() < 1)
1259  return false;
1260  ret = argout(0);
1261  return true;
1262  }
1263 
1264  bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
1265  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1266  member_value_pair *m = nc_this->find_member(symbol, false);
1267  if (!m || m->first->is_static() || m->first->is_global())
1268  return false;
1269  octave_value_list args;
1270  args.append(nc_this->as_value());
1271  args.append(rhs);
1272  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1273  if (argout.length() >= 1)
1274  ret = argout(0);
1275  return true;
1276  }
1277 
1278  octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1279  if (m->second.is_defined()) {
1280  if (m->second.is_function() || m->second.is_function_handle()) {
1281  return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args);
1282  } else {
1283  return m->second;
1284  }
1285  } else if (m->first) {
1286  if (m->first->get_method)
1287  return m->first->get_method(args, 1);
1288  else if (m->first->method)
1289  return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args);
1290  }
1291  error("undefined member");
1292  return octave_value_list();
1293  }
1294 
1295  static octave_value make_value_hack(const octave_base_value &x) {
1296  ((octave_swig_type &) x).count++;
1297  return octave_value((octave_base_value *) &x);
1298  }
1299 
1302  public:
1303 
1304  octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1305  bool _always_static = false)
1306  : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1307  always_static(_always_static) {
1308  if (_type || _ptr)
1309  types.push_back(std::make_pair(_type, _ptr));
1310 #ifdef SWIG_DIRECTORS
1311  if (_ptr) {
1312  Swig::Director *d = Swig::get_rtdir(_ptr);
1313  if (d)
1314  Swig::swig_director_set_self(d, this);
1315  }
1316 #endif
1317  }
1318 
1320  if (own) {
1321  ++count;
1322  for (unsigned int j = 0; j < types.size(); ++j) {
1323  if (!types[j].first || !types[j].first->clientdata)
1324  continue;
1325  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1326  if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1327  c->destructor(as_value(), 0);
1328  }
1329  }
1330  }
1331 #ifdef SWIG_DIRECTORS
1332  for (unsigned int j = 0; j < types.size(); ++j)
1333  Swig::erase_rtdir(types[j].second.ptr);
1334 #endif
1335  }
1336 
1337  dim_vector dims(void) const {
1338  octave_value out;
1339  if (!dispatch_unary_op("__dims__", out))
1340  return dim_vector(1,1);
1341 
1342  // Return value should be cell or matrix of integers
1343 #if SWIG_OCTAVE_PREREQ(4,4,0)
1344  if (out.iscell()) {
1345 #else
1346  if (out.is_cell()) {
1347 #endif
1348  const Cell & c=out.cell_value();
1349  int ndim = c.rows();
1350  if (ndim==1 && c.columns()!=1) ndim = c.columns();
1351 
1352  dim_vector d;
1353  d.resize(ndim < 2 ? 2 : ndim);
1354  d(0) = d(1) = 1;
1355 
1356  // Fill in dim_vector
1357  for (int k=0;k<ndim;k++) {
1358  const octave_value& obj = c(k);
1359 #if SWIG_OCTAVE_PREREQ(6,0,0)
1360  try {
1361  d.elem(k) = obj.int_value();
1362  }
1363  catch (octave::execution_exception& oee) {
1364  // __dims__ should return a cell filled with integers
1365  return dim_vector(1,1);
1366  }
1367 #else
1368  d.elem(k) = obj.int_value();
1369 
1370  // __dims__ should return a cell filled with integers
1371  if (error_state) return dim_vector(1,1);
1372 #endif
1373  }
1374  return d;
1375 #if SWIG_OCTAVE_PREREQ(4,4,0)
1376  } else if (out.is_matrix_type() || out.isnumeric() ) {
1377 #else
1378  } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1379 #endif
1380  if (out.rows()==1 || out.columns()==1) {
1381 #if SWIG_OCTAVE_PREREQ(6,0,0)
1382  Array<int> a;
1383  try {
1384  a = out.int_vector_value();
1385  }
1386  catch (octave::execution_exception& oee) {
1387  return dim_vector(1,1);
1388  }
1389 #else
1390  Array<int> a = out.int_vector_value();
1391  if (error_state) return dim_vector(1,1);
1392 #endif
1393  dim_vector d;
1394  d.resize(a.numel() < 2 ? 2 : a.numel());
1395  d(0) = d(1) = 1;
1396  for (int k=0;k<a.numel();k++) {
1397  d.elem(k) = a(k);
1398  }
1399  return d;
1400  } else {
1401  return dim_vector(1,1);
1402  }
1403  } else {
1404  return dim_vector(1,1);
1405  }
1406  }
1407 
1408  octave_value as_value() {
1409  ++count;
1410  return Swig::swig_value_ref(this);
1411  }
1412 
1413  void incref() {
1414  ++count;
1415  }
1416 
1417  void decref() {
1418  if (!--count)
1419  delete this;
1420  }
1421 
1422  size_t swig_this() const {
1423  if (!types.size())
1424  return (size_t) this;
1425  return (size_t) types[0].second.ptr;
1426  }
1427  const char* help_text() const {
1428  if (!types.size())
1429  return 0;
1430  if (!types[0].first->clientdata)
1431  return 0;
1432  swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1433  return c->constructor_doc;
1434  }
1435 
1436  std::string swig_type_name() const {
1437  // * need some way to manually name subclasses.
1438  // * eg optional first arg to subclass(), or named_subclass()
1439  std::string ret;
1440  for (unsigned int j = 0; j < types.size(); ++j) {
1441  if (j)
1442  ret += "_";
1443  if (types[j].first->clientdata) {
1444  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1445  ret += c->name;
1446  } else
1447  ret += types[j].first->name;
1448  }
1449  return ret;
1450  }
1451 
1453  rhs.own = 0;
1454  for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1455  assert(!rhs.types[j].second.destroyed);
1456 #ifdef SWIG_DIRECTORS
1457  Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1458  if (d)
1459  Swig::swig_director_set_self(d, this);
1460 #endif
1461  }
1462  types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1463  members.insert(rhs.members.begin(), rhs.members.end());
1464 #if SWIG_OCTAVE_PREREQ(4,4,0)
1465  assign(rhs.swig_type_name(), rhs.as_value());
1466 #else
1467  rhs.types.clear();
1468  rhs.members.clear();
1469 #endif
1470  }
1471 
1472  typedef member_map::const_iterator swig_member_const_iterator;
1473  swig_member_const_iterator swig_members_begin() { return members.begin(); }
1474  swig_member_const_iterator swig_members_end() { return members.end(); }
1475 
1476  int cast(void **vptr, swig_type_info *type, int *_own, int flags) {
1477  int res = SWIG_ERROR;
1478  if (_own)
1479  *_own = own;
1480  if (flags &SWIG_POINTER_DISOWN)
1481  own = 0;
1482  if (!type && types.size()) {
1483  if(vptr)
1484  *vptr = types[0].second.ptr;
1485  return SWIG_OK;
1486  }
1487  for (unsigned int j = 0; j < types.size(); ++j)
1488  if (type == types[j].first) {
1489  if(vptr)
1490  *vptr = types[j].second.ptr;
1491  return SWIG_OK;
1492  }
1493  for (unsigned int j = 0; j < types.size(); ++j) {
1494  swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1495  if (!tc)
1496  continue;
1497  if(vptr) {
1498  int newmemory = 0;
1499  *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1500  if (newmemory == SWIG_CAST_NEW_MEMORY) {
1501  assert(_own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1502  if (_own)
1503  *_own = *_own | SWIG_CAST_NEW_MEMORY;
1504  }
1505  }
1506  res = SWIG_OK;
1507  break;
1508  }
1509  return res;
1510  }
1511 
1512  bool is_owned() const {
1513  return own;
1514  }
1515 
1516 #ifdef SWIG_DIRECTORS
1517  void director_destroyed(Swig::Director *d) {
1518  bool found = false;
1519  for (unsigned int j = 0; j < types.size(); ++j) {
1520  Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1521  if (dj == d) {
1522  types[j].second.destroyed = true;
1523  found = true;
1524  }
1525  }
1526  assert(found);
1527  }
1528 #endif
1529 
1530  void assign(const std::string &name, const octave_value &ov) {
1531  members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1532  }
1533 
1534  void assign(const std::string &name, const swig_octave_member *m) {
1535  members[name] = std::make_pair(m, octave_value());
1536  }
1537 
1538  octave_base_value *clone() const {
1539  // pass-by-value is probably not desired, and is harder;
1540  // requires calling copy constructors of contained types etc.
1541  assert(0);
1542  *(int *) 0 = 0;
1543  return 0;
1544  }
1545 
1546  octave_base_value *empty_clone() const {
1547  return new octave_swig_type();
1548  }
1549 
1550  bool is_defined() const {
1551  return true;
1552  }
1553 
1554 #if SWIG_OCTAVE_PREREQ(6,0,0)
1555  virtual bool isstruct() const {
1556 #else
1557  virtual bool is_map() const {
1558 #endif
1559  return true;
1560  }
1561 
1562  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1563  octave_value_list ovl = subsref(ops, idx, 1);
1564  return ovl.length()? ovl(0) : octave_value();
1565  }
1566 
1567  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1568  assert(ops.size() > 0);
1569  assert(ops.size() == idx.size());
1570 
1571  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1572  int skip = 0;
1573  octave_value_list sub_ovl;
1574 
1575  // constructor invocation
1576  if (ops[skip] == '(' && construct_type) {
1577  assert(construct_type->clientdata);
1578  swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
1579  if (!c->constructor) {
1580  error("cannot create instance");
1581  return octave_value_list();
1582  }
1583  octave_value_list args;
1584  if (c->director)
1585  args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1586  args.append(*idx_it++);
1587  ++skip;
1588  sub_ovl = c->constructor(args, nargout);
1589  }
1590  // member dereference or invocation
1591  else if (ops[skip] == '.') {
1592  std::string subname;
1593  const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1594  for (;;) {
1595  octave_value_list subname_ovl(*idx_it++);
1596  ++skip;
1597  assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1598  subname = subname_ovl(0).string_value();
1599 
1600  const swig_type_info *next_base = find_base(subname, base);
1601  if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1602  break;
1603  base = next_base;
1604  }
1605 
1606  member_value_pair tmp, *m = &tmp;
1607  if (!base || !(m->first = find_member(base, subname)))
1608  m = find_member(subname, false);
1609  if (!m) {
1610  error("member not found");
1611  return octave_value_list();
1612  }
1613 
1614  octave_value_list args;
1615  if (!always_static &&
1616  (!m->first || (!m->first->is_static() && !m->first->is_global())))
1617  args.append(as_value());
1618  if (skip < (int) ops.size() && ops[skip] == '(' &&
1619  ((m->first && m->first->method) || m->second.is_function() ||
1620  m->second.is_function_handle())) {
1621  args.append(*idx_it++);
1622  ++skip;
1623  sub_ovl = member_invoke(m, args, nargout);
1624  } else {
1625  sub_ovl = member_deref(m, args);
1626  }
1627  }
1628  // index operator
1629  else {
1630  if (ops[skip] == '(' || ops[skip] == '{') {
1631  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1632  octave_value_list args;
1633  args.append(*idx_it++);
1634  ++skip;
1635  if (!dispatch_index_op(op_name, args, sub_ovl)) {
1636  error("error evaluating index operator");
1637  return octave_value_list();
1638  }
1639  } else {
1640  error("unsupported subsref");
1641  return octave_value_list();
1642  }
1643  }
1644 
1645  if (skip >= (int) ops.size())
1646  return sub_ovl;
1647  if (sub_ovl.length() < 1) {
1648  error("bad subs ref");
1649  return octave_value_list();
1650  }
1651  return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1652  }
1653 
1654  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1655  assert(ops.size() > 0);
1656  assert(ops.size() == idx.size());
1657 
1658  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1659  int skip = 0;
1660 
1661  if (ops.size() > 1) {
1662  std::list < octave_value_list >::const_iterator last = idx.end();
1663  --last;
1664  std::list < octave_value_list > next_idx(idx.begin(), last);
1665  octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1666  next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1667  }
1668 
1669  else if (ops[skip] == '(' || ops[skip] == '{') {
1670  const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1671  member_value_pair *m = find_member(op_name, false);
1672  if (m) {
1673  octave_value_list args;
1674  args.append(as_value());
1675  args.append(*idx_it);
1676  args.append(rhs);
1677  member_invoke(m, args, 1);
1678  } else
1679  error("%s member not found", op_name);
1680  }
1681 
1682  else if (ops[skip] == '.') {
1683  octave_value_list subname_ovl(*idx_it++);
1684  ++skip;
1685  assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1686  std::string subname = subname_ovl(0).string_value();
1687 
1688  member_value_pair *m = find_member(subname, true);
1689  if (!m->first || !m->first->set_method) {
1690  m->first = 0;
1691  m->second = rhs;
1692  } else if (m->first->set_method) {
1693  octave_value_list args;
1694  if (!m->first->is_static() && !m->first->is_global())
1695  args.append(as_value());
1696  args.append(rhs);
1697  m->first->set_method(args, 1);
1698  } else
1699  error("member not assignable");
1700  } else
1701  error("unsupported subsasgn");
1702 
1703  return as_value();
1704  }
1705 
1706 #if SWIG_OCTAVE_PREREQ(6,0,0)
1707  virtual bool isobject() const {
1708 #else
1709  virtual bool is_object() const {
1710 #endif
1711  return true;
1712  }
1713 
1714  virtual bool is_string() const {
1715  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1716  return !!nc_this->find_member("__str__", false);
1717  }
1718 
1719  virtual std::string string_value(bool force = false) const {
1720  octave_value ret;
1721  if (!dispatch_unary_op("__str__", ret)) {
1722  error("__str__ method not defined");
1723  return std::string();
1724  }
1725  if (!ret.is_string()) {
1726  error("__str__ method did not return a string");
1727  return std::string();
1728  }
1729  return ret.string_value();
1730  }
1731 
1732  virtual double scalar_value(bool frc_str_conv = false) const {
1733  octave_value ret;
1734  if (!dispatch_unary_op("__float__", ret)) {
1735  error("__float__ method not defined");
1736  }
1737  return ret.scalar_value();
1738  }
1739 
1740 #if SWIG_OCTAVE_PREREQ(4,2,0)
1741  virtual octave_value as_double(void) const {
1742  octave_value ret;
1743  if (!dispatch_unary_op("__float__", ret)) {
1744  error("__float__ method not defined");
1745  }
1746  return ret.as_double();
1747  }
1748 
1749  virtual octave_value as_single(void) const {
1750  octave_value ret;
1751  if (!dispatch_unary_op("__float__", ret)) {
1752  error("__float__ method not defined");
1753  }
1754  return ret.as_single();
1755  }
1756 #endif
1757 
1758 #if SWIG_OCTAVE_PREREQ(3,8,0)
1759  virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
1760  const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
1761  octave_value ret;
1762  if (!dispatch_unary_op(opname, ret)) {
1763  error("%s", (opname + std::string(" method not found")).c_str());
1764  return octave_value();
1765  }
1766  return ret;
1767  }
1768 #endif
1769 
1770 #if SWIG_OCTAVE_PREREQ(3,3,52)
1771  virtual octave_map map_value() const {
1772  return octave_map();
1773  }
1774 #else
1775  virtual Octave_map map_value() const {
1776  return Octave_map();
1777  }
1778 #endif
1779 
1780  virtual string_vector map_keys() const {
1781  member_map tmp;
1782  load_members(tmp);
1783 
1784  string_vector keys(tmp.size());
1785  int k = 0;
1786  for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1787  keys(k++) = it->first;
1788 
1789  return keys;
1790  }
1791 
1792  virtual bool save_ascii (std::ostream& os) {
1793  return true;
1794  }
1795 
1796  virtual bool load_ascii (std::istream& is) {
1797  return true;
1798  }
1799 
1800  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1801  return true;
1802  }
1803 
1804  virtual bool load_binary (std::istream& is, bool swap,
1805 #if SWIG_OCTAVE_PREREQ(6,0,0)
1806  octave::mach_info::float_format fmt) {
1807 #else
1808  oct_mach_info::float_format fmt) {
1809 #endif
1810  return true;
1811  }
1812 
1813 #if defined (HAVE_HDF5)
1814 # if SWIG_OCTAVE_PREREQ(4,0,0)
1815  virtual bool
1816  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
1817  return true;
1818  }
1819 
1820  virtual bool
1821  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
1822  return true;
1823  }
1824 # else
1825  virtual bool
1826  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1827  return true;
1828  }
1829 
1830  virtual bool
1831  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1832  return true;
1833  }
1834 # endif
1835 #endif
1836 
1837  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1838  return string_value();
1839  }
1840 
1841  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1842  return string_value();
1843  }
1844 
1845  static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1846  // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1847  // (rather than any module namespace).
1848 
1849  octave_function *fcn = is_valid_function(symbol, std::string(), false);
1850  if (!fcn)
1851  return false;
1852 #if SWIG_OCTAVE_PREREQ(4,4,0)
1853  octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1854  octave_value_list retval = fcn->call(tw, 1, args);
1855  if (retval.length() == 1)
1856  ret = retval(0);
1857 #else
1858  ret = fcn->do_multi_index_op(1, args)(0);
1859 #endif
1860  return true;
1861  }
1862 
1863  static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1865  assert(ost);
1866 
1867  octave_value ret;
1868  if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1869  return ret;
1870  std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1871  octave_value_list args;
1872  args.append(make_value_hack(x));
1873  if (dispatch_global_op(symbol, args, ret))
1874  return ret;
1875 
1876  error("could not dispatch unary operator");
1877  return octave_value();
1878  }
1879 
1880  static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1881  octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
1882  octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
1883 
1884  octave_value ret;
1885  if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1886  return ret;
1887  if (rhs_ost) {
1888  if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1889  if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1890  return ret;
1891  if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1892  return ret;
1893  }
1894  if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1895  return ret;
1896  }
1897 
1898  std::string symbol;
1899  octave_value_list args;
1900  args.append(make_value_hack(lhs));
1901  args.append(make_value_hack(rhs));
1902 
1903  symbol = SWIG_op_prefix;
1904  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1905  symbol += "_";
1906  symbol += op_name;
1907  symbol += "_";
1908  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1909  if (dispatch_global_op(symbol, args, ret))
1910  return ret;
1911 
1912  symbol = SWIG_op_prefix;
1913  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1914  symbol += "_";
1915  symbol += op_name;
1916  symbol += "_";
1917  symbol += "any";
1918  if (dispatch_global_op(symbol, args, ret))
1919  return ret;
1920 
1921  symbol = SWIG_op_prefix;
1922  symbol += "any";
1923  symbol += "_";
1924  symbol += op_name;
1925  symbol += "_";
1926  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1927  if (dispatch_global_op(symbol, args, ret))
1928  return ret;
1929 
1930  error("could not dispatch binary operator");
1931  return octave_value();
1932  }
1933 
1934 #if SWIG_OCTAVE_PREREQ(4,0,0)
1935  void print(std::ostream &os, bool pr_as_read_syntax = false)
1936 #else
1937  void print(std::ostream &os, bool pr_as_read_syntax = false) const
1938 #endif
1939  {
1940  if (is_string()) {
1941  os << string_value();
1942  return;
1943  }
1944 
1945  member_map tmp;
1946  load_members(tmp);
1947 
1948  indent(os);
1949  os << "{"; newline(os);
1950  increment_indent_level();
1951  for (unsigned int j = 0; j < types.size(); ++j) {
1952  indent(os);
1953  if (types[j].first->clientdata) {
1954  const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1955  os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1956  } else {
1957  os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1958  }
1959  }
1960  for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1961  indent(os);
1962  if (it->second.first) {
1963  const char *objtype = it->second.first->method ? "method" : "variable";
1964  const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1965  os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1966  assert(it->second.first->name == it->first);
1967  } else {
1968  os << it->first; newline(os);
1969  }
1970  }
1971  decrement_indent_level();
1972  indent(os);
1973  os << "}"; newline(os);
1974  }
1975  };
1976 
1977  // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1978  // will call clone() via make_unique() if there is more than one outstanding
1979  // reference to the lhs, and forces the clone's reference count to 1
1980  // (so you can't just increment your own count and return this).
1981  //
1982  // One way to fix this (without modifying Octave) is to add a level of
1983  // indirection such that clone copies ref-counted pointer and we keep
1984  // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1985  //
1986  // Supporting both pass-by-{ref,value} and toggling via %feature/option
1987  // might be nice.
1988 
1989  class octave_swig_ref:public octave_base_value {
1991  public:
1993  :ptr(_ptr)
1994  {
1995  // Ensure type_id() is set correctly
1996  if (t_id == -1) {
1997  t_id = octave_swig_ref::static_type_id();
1998  }
1999  }
2000 
2002  { if (ptr) ptr->decref(); }
2003 
2005  { return ptr; }
2006 
2007  octave_base_value *clone() const
2008  { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
2009 
2010  octave_base_value *empty_clone() const
2011  { return new octave_swig_ref(0); }
2012 
2013  dim_vector dims(void) const
2014  { return ptr->dims(); }
2015 
2016  bool is_defined() const
2017  { return ptr->is_defined(); }
2018 
2019 #if SWIG_OCTAVE_PREREQ(6,0,0)
2020  virtual bool isstruct() const
2021  { return ptr->isstruct(); }
2022 #else
2023  virtual bool is_map() const
2024  { return ptr->is_map(); }
2025 #endif
2026 
2027  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
2028  { return ptr->subsref(ops, idx); }
2029 
2030  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
2031  { return ptr->subsref(ops, idx, nargout); }
2032 
2033  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
2034  { return ptr->subsasgn(ops, idx, rhs); }
2035 
2036 #if SWIG_OCTAVE_PREREQ(6,0,0)
2037  virtual bool isobject() const
2038  { return ptr->isobject(); }
2039 #else
2040  virtual bool is_object() const
2041  { return ptr->is_object(); }
2042 #endif
2043 
2044  virtual bool is_string() const
2045  { return ptr->is_string(); }
2046 
2047  virtual std::string string_value(bool force = false) const
2048  { return ptr->string_value(force); }
2049 
2050  virtual double scalar_value(bool frc_str_conv = false) const
2051  { return ptr->scalar_value(frc_str_conv); }
2052 
2053 #if SWIG_OCTAVE_PREREQ(4,2,0)
2054  virtual octave_value as_double(void) const
2055  { return ptr->as_double(); }
2056 
2057  virtual octave_value as_single(void) const
2058  { return ptr->as_single(); }
2059 #endif
2060 
2061 #if SWIG_OCTAVE_PREREQ(3,8,0)
2062  virtual octave_value map(octave_base_value::unary_mapper_t umap) const
2063  { return ptr->map(umap); }
2064 #endif
2065 
2066 #if SWIG_OCTAVE_PREREQ(3,3,52)
2067  virtual octave_map map_value() const
2068  { return ptr->map_value(); }
2069 #else
2070  virtual Octave_map map_value() const
2071  { return ptr->map_value(); }
2072 #endif
2073 
2074  virtual string_vector map_keys() const
2075  { return ptr->map_keys(); }
2076 
2077  virtual bool save_ascii (std::ostream& os)
2078  { return ptr->save_ascii(os); }
2079 
2080  virtual bool load_ascii (std::istream& is)
2081  { return ptr->load_ascii(is); }
2082 
2083  virtual bool save_binary (std::ostream& os, bool& save_as_floats)
2084  { return ptr->save_binary(os, save_as_floats); }
2085 
2086  virtual bool load_binary (std::istream& is, bool swap,
2087 #if SWIG_OCTAVE_PREREQ(6,0,0)
2088  octave::mach_info::float_format fmt)
2089 #else
2090  oct_mach_info::float_format fmt)
2091 #endif
2092  { return ptr->load_binary(is, swap, fmt); }
2093 
2094 #if defined (HAVE_HDF5)
2095 # if SWIG_OCTAVE_PREREQ(4,0,0)
2096  virtual bool
2097  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
2098  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2099 
2100  virtual bool
2101  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
2102  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2103 # else
2104  virtual bool
2105  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
2106  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2107 
2108  virtual bool
2109  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
2110  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2111 # endif
2112 #endif
2113 
2114  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
2115  { return ptr->convert_to_str(pad, force, type); }
2116 
2117  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
2118  { return ptr->convert_to_str_internal(pad, force, type); }
2119 
2120 #if SWIG_OCTAVE_PREREQ(4,0,0)
2121  void print(std::ostream &os, bool pr_as_read_syntax = false)
2122 #else
2123  void print(std::ostream &os, bool pr_as_read_syntax = false) const
2124 #endif
2125  { return ptr->print(os, pr_as_read_syntax); }
2126 
2127 #if SWIG_OCTAVE_PREREQ(4,4,0)
2128  static void set_type_id(int type_id) { t_id=type_id; }
2129 #endif
2130 
2131  virtual type_conv_info numeric_conversion_function(void) const {
2132  return octave_base_value::type_conv_info (default_numeric_conversion_function,
2133  octave_scalar::static_type_id ());
2134  }
2135 
2136  private:
2137  static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
2138  const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
2139  return new octave_scalar(v.scalar_value());
2140  }
2141 
2142 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2144 #endif
2146  };
2147 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2149 #endif
2151 
2152  class octave_swig_packed:public octave_base_value {
2154  std::vector < char > buf;
2155  public:
2156 
2157  octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
2158  : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len)
2159  {
2160  // Ensure type_id() is set correctly
2161  if (t_id == -1) {
2162  t_id = octave_swig_packed::static_type_id();
2163  }
2164  }
2165 
2166  bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
2167  if (outtype && outtype != type)
2168  return false;
2169  assert(sz <= buf.size());
2170  std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
2171  return true;
2172  }
2173 
2174  octave_base_value *clone() const {
2175  return new octave_swig_packed(*this);
2176  }
2177 
2178  octave_base_value *empty_clone() const {
2179  return new octave_swig_packed();
2180  }
2181 
2182  bool is_defined() const {
2183  return true;
2184  }
2185 
2186 #if SWIG_OCTAVE_PREREQ(4,0,0)
2187  void print(std::ostream &os, bool pr_as_read_syntax = false)
2188 #else
2189  void print(std::ostream &os, bool pr_as_read_syntax = false) const
2190 #endif
2191  {
2192  indent(os);
2193  os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
2194  }
2195 
2196 
2197  virtual bool save_ascii (std::ostream& os) {
2198  return true;
2199  }
2200 
2201  virtual bool load_ascii (std::istream& is) {
2202  return true;
2203  }
2204 
2205  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
2206  return true;
2207  }
2208 
2209  virtual bool load_binary (std::istream& is, bool swap,
2210 #if SWIG_OCTAVE_PREREQ(6,0,0)
2211  octave::mach_info::float_format fmt) {
2212 #else
2213  oct_mach_info::float_format fmt) {
2214 #endif
2215  return true;
2216  }
2217 
2218 #if defined (HAVE_HDF5)
2219 # if SWIG_OCTAVE_PREREQ(4,0,0)
2220  virtual bool
2221  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
2222  return true;
2223  }
2224 
2225  virtual bool
2226  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
2227  return true;
2228  }
2229 # else
2230  virtual bool
2231  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
2232  return true;
2233  }
2234 
2235  virtual bool
2236  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
2237  return true;
2238  }
2239 # endif
2240 #endif
2241 
2242 #if SWIG_OCTAVE_PREREQ(4,4,0)
2243  static void set_type_id(int type_id) { t_id=type_id; }
2244 #endif
2245 
2246  private:
2247 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2249 #endif
2251  };
2252 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2254 #endif
2256 
2257  SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
2258  error("attempt to set immutable member variable");
2259  return octave_value_list();
2260  }
2261 
2263  const octave_value_list &ovl;
2264  int j;
2265 
2266  octave_value_ref(const octave_value_list &_ovl, int _j)
2267  :ovl(_ovl), j(_j) { }
2268 
2269  operator octave_value() const {
2270  return ovl(j);
2271  }
2272 
2273  octave_value operator*() const {
2274  return ovl(j);
2275  }
2276  };
2277 
2278 
2279 namespace Swig {
2280 
2281  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
2282  return new octave_swig_ref(ost);
2283  }
2284 
2286  if (
2287 #if SWIG_OCTAVE_PREREQ(4,4,0)
2288  ov.iscell()
2289 #else
2290  ov.is_cell()
2291 #endif
2292  && ov.rows() == 1 && ov.columns() == 1)
2293  ov = ov.cell_value()(0);
2294  return swig_value_deref(*ov.internal_rep());
2295  }
2296 
2297  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
2298  if (ov.type_id() != octave_swig_ref::static_type_id())
2299  return 0;
2300  const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2301  return osr->get_ptr();
2302  }
2303 
2304 }
2305 
2306 
2307 #define swig_unary_op(name) \
2308 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2309  return octave_swig_type::dispatch_unary_op(x,#name); \
2310 }
2311 #define swig_binary_op(name) \
2312 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2313  return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2314 }
2315 #if SWIG_OCTAVE_PREREQ(4,4,0)
2316 #define swigreg_unary_op(name) \
2317 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2318 typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2319 #else
2320 #define swigreg_unary_op(name) \
2321 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2322 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2323 #endif
2324 #if SWIG_OCTAVE_PREREQ(4,4,0)
2325 #define swigreg_binary_op(name) \
2326 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2327 typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2328 #else
2329 #define swigreg_binary_op(name) \
2330 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2331 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2332 #endif
2333 
2336  swig_unary_op(uminus);
2337  swig_unary_op(transpose);
2338  swig_unary_op(hermitian);
2341 
2348 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2351 #endif
2361  swig_binary_op(el_ldiv);
2364 
2366 #if SWIG_OCTAVE_PREREQ(4,4,0)
2367  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2368 #endif
2369  swigreg_unary_op(not);
2370  swigreg_unary_op(uplus);
2371  swigreg_unary_op(uminus);
2372  swigreg_unary_op(transpose);
2373  swigreg_unary_op(hermitian);
2374  swigreg_unary_op(incr);
2375  swigreg_unary_op(decr);
2376  }
2377  SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2378 #if SWIG_OCTAVE_PREREQ(4,4,0)
2379  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2380 #endif
2381  swigreg_binary_op(add);
2382  swigreg_binary_op(sub);
2383  swigreg_binary_op(mul);
2384  swigreg_binary_op(div);
2385  swigreg_binary_op(pow);
2386  swigreg_binary_op(ldiv);
2387 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2388  swigreg_binary_op(lshift);
2389  swigreg_binary_op(rshift);
2390 #endif
2391  swigreg_binary_op(lt);
2392  swigreg_binary_op(le);
2393  swigreg_binary_op(eq);
2394  swigreg_binary_op(ge);
2395  swigreg_binary_op(gt);
2396  swigreg_binary_op(ne);
2397  swigreg_binary_op(el_mul);
2398  swigreg_binary_op(el_div);
2399  swigreg_binary_op(el_pow);
2400  swigreg_binary_op(el_ldiv);
2401  swigreg_binary_op(el_and);
2402  swigreg_binary_op(el_or);
2403  }
2405  // here we assume that tid are conseq integers increasing from zero, and
2406  // that our tid is the last one. might be better to have explicit string
2407  // list of types we should bind to, and use lookup_type to resolve their tid.
2408 
2409  SWIG_InstallUnaryOps(tid);
2410  SWIG_InstallBinaryOps(tid, tid);
2411  for (int j = 0; j < tid; ++j) {
2412  SWIG_InstallBinaryOps(j, tid);
2413  SWIG_InstallBinaryOps(tid, j);
2414  }
2415  }
2416 
2417 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2418  int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2419 
2420 #ifdef SWIG_DIRECTORS
2421  Swig::Director *d = Swig::get_rtdir(ptr);
2422  if (d && Swig::swig_director_get_self(d))
2423  return Swig::swig_director_get_self(d)->as_value();
2424 #endif
2425  return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2426 }
2427 
2428 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2429  if (
2430 #if SWIG_OCTAVE_PREREQ(4,4,0)
2431  ov.iscell()
2432 #else
2433  ov.is_cell()
2434 #endif
2435  && ov.rows() == 1 && ov.columns() == 1)
2436  ov = ov.cell_value()(0);
2437  if (!ov.is_defined() ||
2438  (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2439  if (ptr)
2440  *ptr = 0;
2442  }
2443  if (ov.type_id() != octave_swig_ref::static_type_id())
2444  return SWIG_ERROR;
2445  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2446  octave_swig_type *ost = osr->get_ptr();
2447  return ost->cast(ptr, type, own, flags);
2448 }
2449 
2450 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2451  return new octave_swig_packed(type, (char *) ptr, sz);
2452 }
2453 
2454 SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2455  if (!ov.is_defined())
2456  return SWIG_ERROR;
2457  if (ov.type_id() != octave_swig_packed::static_type_id())
2458  return SWIG_ERROR;
2459  octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2460  return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2461 }
2462 
2463 SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2464  module_ns->assign(name, ov);
2465 }
2466 
2468 #if SWIG_OCTAVE_PREREQ(6,0,0)
2469  octave::interpreter *interp = octave::interpreter::the_interpreter ();
2470  return interp->global_varval(name);
2471 #else
2472 #if SWIG_OCTAVE_PREREQ(4,4,0)
2473  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2474  return symtab.global_varval(name);
2475 #else
2476  return get_global_value(name, true);
2477 #endif
2478 #endif
2479 }
2480 
2481 SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2482 #if SWIG_OCTAVE_PREREQ(6,0,0)
2483  octave::interpreter *interp = octave::interpreter::the_interpreter ();
2484  interp->global_assign(name, value);
2485 #elif SWIG_OCTAVE_PREREQ(4,4,0)
2486  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2487  symtab.global_assign(name, value);
2488 #else
2489  set_global_value(name, value);
2490 #endif
2491 }
2492 
2494 #if SWIG_OCTAVE_PREREQ(4,4,0)
2495  octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2496 #if SWIG_OCTAVE_PREREQ(6,0,0)
2497  octave::interpreter *interp = octave::interpreter::the_interpreter ();
2498  interp->assign(name, interp->global_varval(name));
2499  octave::tree_evaluator& tree_eval = interp->get_evaluator();
2500  octave::call_stack& callStack = tree_eval.get_call_stack();
2501  std::shared_ptr<octave::stack_frame> stackFrame = callStack.get_current_stack_frame();
2502  octave::symbol_record sym=symscope.lookup_symbol(name);
2503  stackFrame->mark_global(sym);
2504 #else
2505  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2506  symscope.assign(name, symtab.global_varval(name));
2507  symscope.mark_global(name);
2508 #endif
2509 #else
2510 #if !SWIG_OCTAVE_PREREQ(3,2,0)
2511  link_to_global_variable(curr_sym_tab->lookup(name, true));
2512 #else
2513 #if !SWIG_OCTAVE_PREREQ(3,8,0)
2514  symbol_table::varref(name);
2515 #endif
2516  symbol_table::mark_global(name);
2517 #endif
2518 #endif
2519 }
2520 
2522  octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2523  if (!ov.is_defined() ||
2524  ov.type_id() != octave_swig_packed::static_type_id())
2525  return 0;
2526  const octave_swig_packed* osp =
2527  static_cast < const octave_swig_packed *> (ov.internal_rep());
2528  swig_module_info *pointer = 0;
2529  osp->copy(0, &pointer, sizeof(swig_module_info *));
2530  return pointer;
2531 }
2532 
2533 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2534  octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2536 }
2537 
2538 
2539 
2540 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2541 
2542 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2543 
2544 
2545 
2546 /* -------- TYPES TABLE (BEGIN) -------- */
2547 
2548 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2549 #define SWIGTYPE_p_char swig_types[1]
2550 #define SWIGTYPE_p_double swig_types[2]
2551 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2552 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2553 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2554 #define SWIGTYPE_p_int swig_types[6]
2555 #define SWIGTYPE_p_p_char swig_types[7]
2556 #define SWIGTYPE_p_unsigned_int swig_types[8]
2558 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2559 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2560 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2561 
2562 /* -------- TYPES TABLE (END) -------- */
2563 
2564 
2565 #define SWIGVERSION 0x040002
2566 #define SWIG_VERSION SWIGVERSION
2567 
2568 
2569 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2570 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2571 
2572 
2573 #include <stdexcept>
2574 
2575 
2576 // #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2577 #undef PACKAGE
2578 #undef VERSION
2579 
2580 #include "plplotP.h"
2581 
2582 // Temporary fix for problems with -fvisibility=hidden and octave headers.
2583 #ifdef OCTAVE_EXPORT
2584  #if defined ( __GNUC__ ) && __GNUC__ > 3
2585  #undef OCTAVE_EXPORT
2586  #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2587  #endif
2588 #endif
2589 
2590 
2591 
2592 // I hate global variables but this is the best way I can think of
2593 // to manage consistency checking among function arguments.
2594  static PLINT Alen = 0;
2595  static PLINT Xlen = 0, Ylen = 0;
2596 
2597 
2598 // Convenience functions copied from matwrap-based approach (currently
2599 // stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2600 // tricky scalar case and also adopted so that the resulting
2601 // swig-generated source code will look similar to the matwrap-generated
2602 // source code.
2603 
2604  inline int max( int a, int b )
2605  {
2606  return a >= b ? a : b;
2607  }
2608  inline int min( int a, int b )
2609  {
2610  return a >= b ? a : b;
2611  }
2612 
2613 //
2614 // Function to get the total length (rows*columns) of an octave object of
2615 // arbitrary type.
2616 // Arguments:
2617 // 1) The octave object.
2618 //
2619 // If the object is a scalar, the array length is 1.
2620 //
2621  static int
2622  _arraylen( const octave_value &o_obj )
2623  {
2624  return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2625  // max is necessary because sometimes
2626  // rows() or columns() return -1 or 0 for
2627  // scalars.
2628  }
2629 
2630 //
2631 // Function to get the number of dimensions of an object.
2632 //
2633  static int
2634  _n_dims( const octave_value &o_obj )
2635  {
2636  if ( max( o_obj.columns(), 1 ) > 1 )
2637  return 2;
2638  // max is necessary because sometimes
2639  // rows() or columns() return -1 or 0 for
2640  // scalars.
2641  else if ( max( o_obj.rows(), 1 ) > 1 )
2642  return 1;
2643  else
2644  return 0;
2645  }
2646 
2647 //
2648 // Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2649 //
2650  static inline int
2651  _dim( const octave_value &o_obj, int dim_idx )
2652  {
2653  if ( dim_idx == 0 )
2654  return max( o_obj.rows(), 0 );
2655  // max is necessary because sometimes
2656  // rows() or columns() return -1 or 0 for
2657  // scalars.
2658  else if ( dim_idx == 1 )
2659  return max( o_obj.columns(), 0 );
2660  else
2661  return 1;
2662  }
2663 
2664 //
2665 // The following function converts an array of doubles into some other
2666 // numeric type. Arguments:
2667 // 1) Where to store the result. The type is determined from the type of
2668 // this pointer.
2669 // 2) A vector of doubles to convert.
2670 // 3) The number of doubles.
2671 //
2672  template <class FLOAT>
2673  static inline void
2674  _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2675  {
2676  while ( n_el-- > 0 )
2677  *out_arr++ = (FLOAT) ( *in_arr++ );
2678  }
2679 
2680  template void _cvt_double_to( int *, double *, unsigned );
2681  template void _cvt_double_to( unsigned *, double *, unsigned );
2682  template void _cvt_double_to( long *, double *, unsigned );
2683  template void _cvt_double_to( unsigned long *, double *, unsigned );
2684  template void _cvt_double_to( short *, double *, unsigned );
2685  template void _cvt_double_to( unsigned short *, double *, unsigned );
2686  template void _cvt_double_to( float *, double *, unsigned );
2687  // Instantiate our templates. Octave uses
2688  // manual template instantiation.
2689 
2690 //
2691 // Convert an array of some other type into an array of doubles. Arguments:
2692 // 1) The array of objects of other type.
2693 // 2) The output array of doubles.
2694 // 3) The number of elements to convert.
2695 //
2696  template <class FLOAT>
2697  static inline void
2698  _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2699  {
2700  while ( n_el-- > 0 )
2701  *d_arr++ = double(*arr++);
2702  }
2703 
2704  template void _cvt_to_double( int *, double *, unsigned );
2705  template void _cvt_to_double( unsigned *, double *, unsigned );
2706  template void _cvt_to_double( long *, double *, unsigned );
2707  template void _cvt_to_double( unsigned long *, double *, unsigned );
2708  template void _cvt_to_double( short *, double *, unsigned );
2709  template void _cvt_to_double( unsigned short *, double *, unsigned );
2710  template void _cvt_to_double( float *, double *, unsigned );
2711  // Instantiate our templates. Octave uses
2712  // manual template instantiation.
2713 
2714 
2715  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2716  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2717  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2718  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2719  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2721  typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2722 
2723 
2724 #include <iostream>
2725 
2726  octave_function *fcnMapForm;
2727  std::string nameMapForm;
2728 
2729  void mapform_octave( PLINT n, PLFLT *x, PLFLT *y )
2730  {
2731  octave_idx_type i;
2732  octave_value_list functionArguments;
2733  octave_value_list retval;
2734 
2735  Matrix xin( n, 1 );
2736  Matrix yin( n, 1 );
2737  Matrix xout;
2738  Matrix yout;
2739 
2740  for ( i = 0; i < n; i++ )
2741  {
2742  xin( i, 0 ) = x[i];
2743  yin( i, 0 ) = y[i];
2744  }
2745 
2746  functionArguments( 0 ) = xin;
2747  functionArguments( 1 ) = yin;
2748 
2749  if ( fcnMapForm != NULL )
2750 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2751  retval = octave::feval( fcnMapForm, functionArguments, 1 );
2752 #else
2753  retval = feval( fcnMapForm, functionArguments, 1 );
2754 #endif
2755  else
2756 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2757  retval = octave::feval( nameMapForm, functionArguments, 1 );
2758 #else
2759  retval = feval( nameMapForm, functionArguments, 1 );
2760 #endif
2761 
2762  if ( retval.length() >= 2 )
2763  {
2764  xout = retval( 0 ).matrix_value();
2765  yout = retval( 1 ).matrix_value();
2766 
2767  for ( i = 0; i < n; i++ )
2768  {
2769  x[i] = xout( i, 0 );
2770  y[i] = yout( i, 0 );
2771  }
2772  }
2773  }
2774 
2775 
2776  octave_function *fcnLabelFunc;
2777  std::string nameLabelFunc;
2778 
2779  void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2780  {
2781  int i;
2782  octave_value_list functionArguments;
2783  octave_value_list retval;
2784 
2785  Matrix inAxis( 1, 1 );
2786  Matrix inValue( 1, 1 );
2787  inAxis( 0, 0 ) = axis;
2788  inValue( 0, 0 ) = value;
2789 
2790  functionArguments( 0 ) = inAxis;
2791  functionArguments( 1 ) = inValue;
2792 
2793  if ( fcnLabelFunc != NULL )
2794 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2795  retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2796 #else
2797  retval = feval( fcnLabelFunc, functionArguments, 1 );
2798 #endif
2799  else
2800 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2801  retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2802 #else
2803  retval = feval( nameLabelFunc, functionArguments, 1 );
2804 #endif
2805 
2806  strncpy( label, retval( 0 ).string_value().c_str(), length );
2807  }
2808 
2809 
2810  octave_function *fcnCoordTrans;
2811  std::string nameCoordTrans;
2812 
2813  void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2814  {
2815  octave_idx_type i;
2816  octave_value_list functionArguments;
2817  octave_value_list retval;
2818 
2819  Matrix xin( 1, 1 );
2820  Matrix yin( 1, 1 );
2821  Matrix xout;
2822  Matrix yout;
2823 
2824  xin( 0, 0 ) = x;
2825  yin( 0, 0 ) = y;
2826 
2827  functionArguments( 0 ) = xin;
2828  functionArguments( 1 ) = yin;
2829 
2830  if ( fcnCoordTrans != NULL )
2831 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2832  retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2833 #else
2834  retval = feval( fcnCoordTrans, functionArguments, 1 );
2835 #endif
2836  else
2837 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2838  retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2839 #else
2840  retval = feval( nameCoordTrans, functionArguments, 1 );
2841 #endif
2842 
2843  if ( retval.length() >= 2 )
2844  {
2845  xout = retval( 0 ).matrix_value();
2846  yout = retval( 1 ).matrix_value();
2847 
2848  *xt = xout( 0, 0 );
2849  *yt = yout( 0, 0 );
2850  }
2851  }
2852 
2853 
2854  void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2855  {
2856  PLINT i;
2857  printf( "nlegend =%d\n", nlegend );
2858  for ( i = 0; i < nlegend; i++ )
2859  {
2860  printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2861  printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2862  printf( "text[%d] =%s\n", i, text[i] );
2863  }
2864  }
2865 
2866 
2867 #include <limits.h>
2868 #if !defined(SWIG_NO_LLONG_MAX)
2869 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2870 # define LLONG_MAX __LONG_LONG_MAX__
2871 # define LLONG_MIN (-LLONG_MAX - 1LL)
2872 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2873 # endif
2874 #endif
2875 
2876 
2877  SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2878  {
2879  if (!ov.is_scalar_type())
2880  return SWIG_TypeError;
2881  if (ov.is_complex_scalar())
2882  return SWIG_TypeError;
2883  if (ov.is_double_type()||ov.is_single_type()) {
2884  double v=ov.double_value();
2885  if (v!=floor(v))
2886  return SWIG_TypeError;
2887  }
2888  if (val)
2889  *val = ov.long_value();
2890  return SWIG_OK;
2891  }
2892 
2893 
2894 SWIGINTERN int
2895 SWIG_AsVal_int (octave_value obj, int *val)
2896 {
2897  long v;
2898  int res = SWIG_AsVal_long (obj, &v);
2899  if (SWIG_IsOK(res)) {
2900  if ((v < INT_MIN || v > INT_MAX)) {
2901  return SWIG_OverflowError;
2902  } else {
2903  if (val) *val = static_cast< int >(v);
2904  }
2905  }
2906  return res;
2907 }
2908 
2909 
2910  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 )
2911  {
2912  PLGraphicsIn gin;
2913  int status; status = plGetCursor( &gin );
2914  *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2915  strncpy( string, gin.string, PL_MAXKEY - 1 );
2916  string[PL_MAXKEY - 1] = '\0';
2917 
2918  *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2919  return status;
2920  }
2921 
2922 
2923 SWIGINTERN int
2924 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2925 {
2926  if (
2927 #if SWIG_OCTAVE_PREREQ(4,4,0)
2928  ov.iscell()
2929 #else
2930  ov.is_cell()
2931 #endif
2932  && ov.rows() == 1 && ov.columns() == 1)
2933  ov = ov.cell_value()(0);
2934  if (!ov.is_string())
2935  return SWIG_TypeError;
2936 
2937  std::string str=ov.string_value();
2938  size_t len=str.size();
2939  char* cstr=(char*)str.c_str();
2940  if (alloc) {
2941  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
2942  *alloc = SWIG_NEWOBJ;
2943  } else if (cptr)
2944  *cptr = cstr;
2945  if (psize)
2946  *psize = len + 1;
2947  return SWIG_OK;
2948 }
2949 
2950 
2951 
2952 
2953 
2955  {
2956  return octave_value(value);
2957  }
2958 
2959 
2960 SWIGINTERNINLINE octave_value
2962 {
2963  return SWIG_From_long (value);
2964 }
2965 
2966 
2968  {
2969  return octave_value(value);
2970  }
2971 
2972 
2973 // Translates relative device coordinates to world coordinates.
2974  static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2975  {
2976  PLGraphicsIn gin;
2977  int st;
2978  gin.dX = x_in; gin.dY = y_in;
2979  st = plTranslateCursor( &gin );
2980  *x = gin.wX; *y = gin.wY;
2981  return st;
2982  }
2983 
2984 
2985  SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2986  {
2987  if (!ov.is_scalar_type())
2988  return SWIG_TypeError;
2989  if (ov.is_complex_scalar())
2990  return SWIG_TypeError;
2991  if (val)
2992  *val = ov.double_value();
2993  return SWIG_OK;
2994  }
2995 
2996 
2997 // Create 1d stripchart
2998 
2999  void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
3000  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
3001  PLFLT xlpos, PLFLT ylpos,
3002  PLBOOL y_ascl, PLBOOL acc,
3003  PLINT colbox, PLINT collab,
3004  const PLINT *colline, const PLINT *styline,
3005  const char *legline1, const char *legline2, const char *legline3, const char *legline4,
3006  const char *labx, const char *laby, const char *labtop )
3007  {
3008  const char *legline[4];
3009  legline[0] = legline1; legline[1] = legline2;
3010  legline[2] = legline3; legline[3] = legline4;
3011  c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
3012  xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
3013  labx, laby, labtop );
3014  }
3015 
3016 
3017 // One more hack. As it is not possible (and would not be desirable) to pass
3018 // an Octave function to plcont(), I have defined three plcont():
3019 // plcont uses a defined here xform()
3020 // plcont0 uses pltr0()
3021 // plcont1 uses pltr1()
3022 // plcont2 uses pltr2()
3023 // plcont2p uses pltr2p()
3024 //
3025 // Also, as plplot expect vectorized bidimensional arrays, I provided a
3026 // f2c, which is a #define that does the necessary conversion.
3027 //
3028 
3029  void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
3030  {
3031  *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
3032  *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
3033  }
3034 
3035 // convert from Fortran like arrays (one vector), to C like 2D arrays
3036 
3037 #define f2c( f, ff, nx, ny ) \
3038  PLFLT * *ff; \
3039  ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
3040  for ( int i = 0; i < nx; i++ ) { \
3041  ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
3042  for ( int j = 0; j < ny; j++ ) \
3043  *( ff[i] + j ) = *( f + nx * j + i );}
3044 
3045 // simpler plcont() for use with xform()
3046 
3047  void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3048  PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
3049  {
3050  f2c( f, ff, nx, ny );
3051  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
3052  }
3053 
3054 // plcont() for use with pltr0() NOT TESTED
3055 
3056  void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3057  PLINT ly, const PLFLT *clevel, PLINT nlevel )
3058  {
3059  f2c( f, ff, nx, ny );
3060  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
3061  }
3062 
3063 // plcont() for use with pltr1()
3064 
3065  void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3066  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3067  {
3068  PLcGrid grid1;
3069  grid1.nx = nx; grid1.ny = ny;
3070  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3071  f2c( f, ff, nx, ny );
3072  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
3073  }
3074 
3075 // plcont() for use with pltr2()
3076  void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3077  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3078  {
3079  PLcGrid2 grid2;
3080  f2c( xg, xgg, nx, ny );
3081  f2c( yg, ygg, nx, ny );
3082  grid2.nx = nx; grid2.ny = ny;
3083  grid2.xg = xgg; grid2.yg = ygg;
3084  f2c( f, ff, nx, ny );
3085  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3086  }
3087 
3088 // plcont() for use with pltr2p()
3089 
3090  void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
3091  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
3092  {
3093  PLcGrid2 grid2;
3094  f2c( xg, xgg, nx, ny );
3095  f2c( yg, ygg, nx, ny );
3096  grid2.nx = nx; grid2.ny = ny;
3097  grid2.xg = xgg; grid2.yg = ygg;
3098  f2c( f, ff, nx, ny );
3099  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
3100  }
3101 
3102 
3103  void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
3104  const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
3105  PLFLT *zg, int type, PLFLT data )
3106  {
3107  f2c( zg, zgg, nptsx, nptsy );
3108  plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
3109  for ( int i = 0; i < nptsx; i++ )
3110  for ( int j = 0; j < nptsy; j++ )
3111  *( zg + nptsx * j + i ) = zgg[i][j];
3112  }
3113 
3114 
3115 // Plots a mesh representation of the function z[x][y].
3116 
3117  void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3118  {
3119  f2c( z, zz, nx, ny );
3120  c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3121  }
3122 
3123 // Plots a mesh representation of the function z[x][y] with contour
3124 
3125  void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3126  {
3127  f2c( z, zz, nx, ny );
3128  c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3129  }
3130 
3131 
3132 // Plots a 3-d representation of the function z[x][y].
3133  void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3134  PLINT nx, PLINT ny, PLINT opt, PLINT side )
3135  {
3136  f2c( z, zz, nx, ny );
3137  c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3138  }
3139 
3140 // Plots a 3-d representation of the function z[x][y] with contour
3141  void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3142  PLINT nx, PLINT ny, PLINT opt,
3143  const PLFLT *clevel, PLINT nlevel )
3144  {
3145  f2c( z, zz, nx, ny );
3146  c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3147  }
3148 // Plots a 3-d representation of the function z[x][y] with contour with y
3149 // index limits
3150  void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3151  PLINT nx, PLINT ny, PLINT opt,
3152  const PLFLT * clevel, PLINT nlevel,
3153  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3154  {
3155  f2c( z, zz, nx, ny );
3156  c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3157  indexxmin, indexxmax, indexymin, indexymax );
3158  }
3159 
3160 
3161  void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3162  PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3163  {
3164  f2c( z, zz, nx, ny );
3165  c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3166  }
3167 
3168  void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3169  PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3170  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3171  {
3172  f2c( z, zz, nx, ny );
3173  c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3174  indexxmin, indexxmax, indexymin, indexymax );
3175  }
3176 
3177 
3178 // The same as in plcont. I have hardcoded the first function pointer
3179 // to plfill(). The second function pointer will use the same convention
3180 // as in plcont().
3181 //
3182 
3183 // the simpler plshade()
3184  void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3185  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3186  PLFLT shade_min, PLFLT shade_max,
3187  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3188  PLINT min_color, PLINT min_width,
3189  PLINT max_color, PLINT max_width,
3190  PLINT rectangular, PLFLT *tr )
3191  {
3192  f2c( a, aa, nx, ny );
3193  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3194  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3195  min_color, min_width, max_color, max_width,
3196  plfill, rectangular, xform, tr );
3197  }
3198 
3199 // plshade() for use with pltr1
3200  void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3201  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3202  PLFLT shade_min, PLFLT shade_max,
3203  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3204  PLINT min_color, PLINT min_width,
3205  PLINT max_color, PLINT max_width,
3206  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3207  {
3208  PLcGrid grid1;
3209  grid1.nx = nx; grid1.ny = ny;
3210  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3211  f2c( a, aa, nx, ny );
3212  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3213  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3214  min_color, min_width, max_color, max_width,
3215  plfill, rectangular, pltr1, &grid1 );
3216  }
3217 
3218 // plshade() for use with pltr2
3219  void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3220  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3221  PLFLT shade_min, PLFLT shade_max,
3222  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3223  PLINT min_color, PLINT min_width,
3224  PLINT max_color, PLINT max_width,
3225  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3226  {
3227  PLcGrid2 grid2;
3228  f2c( xg, xgg, nx, ny );
3229  f2c( yg, ygg, nx, ny );
3230  grid2.nx = nx; grid2.ny = ny;
3231  grid2.xg = xgg; grid2.yg = ygg;
3232  f2c( a, aa, nx, ny );
3233  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3234  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3235  min_color, min_width, max_color, max_width,
3236  plfill, rectangular, pltr2, &grid2 );
3237  }
3238 
3239 
3240 
3241  void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3242  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3243  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3244  PLINT cont_color, PLINT cont_width,
3245  PLINT rectangular )
3246  {
3247  f2c( a, aa, nx, ny );
3248  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3249  clevel, nlevel, fill_width, cont_color, cont_width,
3250  plfill, rectangular, NULL, NULL );
3251  }
3252 
3253  void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3254  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3255  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3256  PLINT cont_color, PLINT cont_width,
3257  PLINT rectangular, PLFLT *tr )
3258  {
3259  f2c( a, aa, nx, ny );
3260  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3261  clevel, nlevel, fill_width, cont_color, cont_width,
3262  plfill, rectangular, xform, tr );
3263  }
3264 
3265  void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3266  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3267  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3268  PLINT cont_color, PLINT cont_width,
3269  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3270  {
3271  PLcGrid grid1;
3272  grid1.nx = nx; grid1.ny = ny;
3273  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3274 
3275  f2c( a, aa, nx, ny );
3276  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3277  clevel, nlevel, fill_width, cont_color, cont_width,
3278  plfill, rectangular, pltr1, &grid1 );
3279  }
3280 
3281  void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3282  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3283  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3284  PLINT cont_color, PLINT cont_width,
3285  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3286  {
3287  PLcGrid2 grid2;
3288  f2c( xg, xgg, nx, ny );
3289  f2c( yg, ygg, nx, ny );
3290  grid2.nx = nx; grid2.ny = ny;
3291  grid2.xg = xgg; grid2.yg = ygg;
3292  f2c( a, aa, nx, ny );
3293  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3294  clevel, nlevel, fill_width, cont_color, cont_width,
3295  plfill, rectangular, pltr2, &grid2 );
3296  }
3297 
3298 
3299 // Plot an array of vector arrows - uses the same function pointer
3300 // convention as plcont
3301 
3302  void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3303  {
3304  f2c( u, uu, nx, ny );
3305  f2c( v, vv, nx, ny );
3306  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3307  }
3308 
3309 // plvect() for use with pltr1
3310  void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3311  {
3312  PLcGrid grid1;
3313  grid1.nx = nx; grid1.ny = ny;
3314  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3315  f2c( u, uu, nx, ny );
3316  f2c( v, vv, nx, ny );
3317  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3318  }
3319 
3320 // plvect() for use with pltr2
3321  void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3322  {
3323  PLcGrid2 grid2;
3324  f2c( xg, xgg, nx, ny );
3325  f2c( yg, ygg, nx, ny );
3326  grid2.nx = nx; grid2.ny = ny;
3327  grid2.xg = xgg; grid2.yg = ygg;
3328  f2c( u, uu, nx, ny );
3329  f2c( v, vv, nx, ny );
3330  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3331  }
3332 
3333 
3334 // Plot an image with distortion - uses the same function pointer
3335  void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3336  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3337  PLFLT zmin, PLFLT zmax,
3338  PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3339  {
3340  f2c( a, aa, nx, ny );
3341  plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3342  }
3343 
3344 // Plot an image with distortion - uses the same function pointer
3345 // convention as plcont
3346  void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3347  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3348  PLFLT zmin, PLFLT zmax,
3349  PLFLT valuemin, PLFLT valuemax )
3350  {
3351  f2c( a, aa, nx, ny );
3352  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3353  }
3354 
3355  void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3356  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3357  PLFLT zmin, PLFLT zmax,
3358  PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3359  {
3360  f2c( a, aa, nx, ny );
3361  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3362  }
3363 
3364 // plimagefr() for use with pltr1
3365  void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3366  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3367  PLFLT zmin, PLFLT zmax,
3368  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3369  {
3370  PLcGrid grid1;
3371  grid1.nx = nx + 1; grid1.ny = ny + 1;
3372  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3373  f2c( a, aa, nx, ny );
3374  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3375  }
3376 
3377 // plimagefr() for use with pltr2
3378  void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3379  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3380  PLFLT zmin, PLFLT zmax,
3381  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3382  {
3383  PLcGrid2 grid2;
3384  f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3385  f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3386  grid2.nx = nx + 1; grid2.ny = ny + 1;
3387  grid2.xg = xgg; grid2.yg = ygg;
3388  f2c( a, aa, nx, ny );
3389  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3390  }
3391 
3392 
3393 
3394  void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3395  PLINT opt, PLINT position, PLFLT x, PLFLT y,
3396  PLFLT x_length, PLFLT y_length,
3397  PLINT bg_color, PLINT bb_color, PLINT bb_style,
3398  PLFLT low_cap_color, PLFLT high_cap_color,
3399  PLINT cont_color, PLFLT cont_width,
3400  PLINT n_labels, const PLINT *label_opts, const char **label,
3401  PLINT n_axes, const char ** axis_opts,
3402  const PLFLT *ticks, const PLINT *sub_ticks,
3403  const PLINT *n_values, const PLFLT *a )
3404  {
3405  PLINT nx, ny, i;
3406  nx = n_axes;
3407  ny = -1;
3408  for ( i = 0; i < nx; i++ )
3409  if ( n_values[i] > ny )
3410  ny = n_values[i];
3411  f2c( a, aa, nx, ny );
3412  c_plcolorbar( p_colorbar_width, p_colorbar_height,
3413  opt, position, x, y,
3414  x_length, y_length,
3415  bg_color, bb_color, bb_style,
3416  low_cap_color, high_cap_color,
3417  cont_color, cont_width,
3418  n_labels, label_opts, label,
3419  n_axes, axis_opts,
3420  ticks, sub_ticks,
3421  n_values, aa );
3422  }
3423 
3424 
3425 
3426  SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3427  {
3428  if (!ov.is_scalar_type())
3429  return SWIG_TypeError;
3430  if (ov.is_complex_scalar())
3431  return SWIG_TypeError;
3432  if (ov.is_double_type()||ov.is_single_type()) {
3433  double v=ov.double_value();
3434  if (v<0)
3435  return SWIG_OverflowError;
3436  if (v!=floor(v))
3437  return SWIG_TypeError;
3438  }
3439  if (ov.is_int8_type()||ov.is_int16_type()||
3440  ov.is_int32_type()) {
3441  long v=ov.long_value();
3442  if (v<0)
3443  return SWIG_OverflowError;
3444  }
3445  if (ov.is_int64_type()) {
3446  long long v=ov.int64_scalar_value().value();
3447  if (v<0)
3448  return SWIG_OverflowError;
3449  }
3450  if (val)
3451  *val = ov.ulong_value();
3452  return SWIG_OK;
3453  }
3454 
3455 
3456 SWIGINTERN int
3457 SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3458 {
3459  unsigned long v;
3460  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3461  if (SWIG_IsOK(res)) {
3462  if ((v > UINT_MAX)) {
3463  return SWIG_OverflowError;
3464  } else {
3465  if (val) *val = static_cast< unsigned int >(v);
3466  }
3467  }
3468  return res;
3469 }
3470 
3471 
3473  {
3474  return octave_value(value);
3475  }
3476 
3477 
3478 SWIGINTERNINLINE octave_value
3480 {
3482 }
3483 
3484 
3485 SWIGINTERN int
3486 SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3487 {
3488  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3489  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3490  if (SWIG_IsOK(res)) {
3491  /* special case of single char conversion when we don't need space for NUL */
3492  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3493  if (csize <= size) {
3494  if (val) {
3495  if (csize) memcpy(val, cptr, csize*sizeof(char));
3496  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3497  }
3498  if (alloc == SWIG_NEWOBJ) {
3499  delete[] cptr;
3500  res = SWIG_DelNewMask(res);
3501  }
3502  return res;
3503  }
3504  if (alloc == SWIG_NEWOBJ) delete[] cptr;
3505  }
3506  return SWIG_TypeError;
3507 }
3508 
3509 
3512 {
3513  static int init = 0;
3514  static swig_type_info* info = 0;
3515  if (!init) {
3516  info = SWIG_TypeQuery("_p_char");
3517  init = 1;
3518  }
3519  return info;
3520 }
3521 
3522 
3523 SWIGINTERNINLINE octave_value
3524 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3525 {
3526  return std::string(carray,carray+size);
3527 }
3528 
3529 
3530 SWIGINTERN size_t
3531 SWIG_strnlen(const char* s, size_t maxlen)
3532 {
3533  const char *p;
3534  for (p = s; maxlen-- && *p; p++)
3535  ;
3536  return p - s;
3537 }
3538 
3539 
3540 SWIGINTERN int
3541 SWIG_AsVal_char (octave_value obj, char *val)
3542 {
3543  int res = SWIG_AsCharArray(obj, val, 1);
3544  if (!SWIG_IsOK(res)) {
3545  long v;
3546  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3547  if (SWIG_IsOK(res)) {
3548  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3549  if (val) *val = static_cast< char >(v);
3550  } else {
3551  res = SWIG_OverflowError;
3552  }
3553  }
3554  }
3555  return res;
3556 }
3557 
3558 static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3559 Specify viewport in absolute coordinates\n\
3560 \n\
3561 DESCRIPTION:\n\
3562 \n\
3563  Alternate routine to plvpor for setting up the viewport. This routine\n\
3564  should be used only if the viewport is required to have a definite\n\
3565  size in millimeters. The routine plgspa is useful for finding out the\n\
3566  size of the current subpage.\n\
3567 \n\
3568  Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3569 \n\
3570  This function is used in example 10.\n\
3571 \n\
3572 \n\
3573 \n\
3574 SYNOPSIS:\n\
3575 \n\
3576 plsvpa(xmin, xmax, ymin, ymax)\n\
3577 \n\
3578 ARGUMENTS:\n\
3579 \n\
3580  xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3581  viewport from the left-hand edge of the subpage in millimeters.\n\
3582 \n\
3583  xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3584  viewport from the left-hand edge of the subpage in millimeters.\n\
3585 \n\
3586  ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3587  viewport from the bottom edge of the subpage in millimeters.\n\
3588 \n\
3589  ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3590  from the bottom edge of the subpage in millimeters.\n\
3591 ";
3592 static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3593 Write text relative to viewport boundaries in 3D plots\n\
3594 \n\
3595 DESCRIPTION:\n\
3596 \n\
3597  Writes text at a specified position relative to the viewport\n\
3598  boundaries. Text may be written inside or outside the viewport, but\n\
3599  is clipped at the subpage boundaries. The reference point of a string\n\
3600  lies along a line passing through the string at half the height of a\n\
3601  capital letter. The position of the reference point along this line\n\
3602  is determined by just, and the position of the reference point\n\
3603  relative to the viewport is set by disp and pos.\n\
3604 \n\
3605  Redacted form: plmtex3(side, disp, pos, just, text)\n\
3606 \n\
3607  This function is used in example 28.\n\
3608 \n\
3609 \n\
3610 \n\
3611 SYNOPSIS:\n\
3612 \n\
3613 plmtex3(side, disp, pos, just, text)\n\
3614 \n\
3615 ARGUMENTS:\n\
3616 \n\
3617  side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3618  the side of the viewport along which the text is to be written.\n\
3619  The string should contain one or more of the following characters:\n\
3620  [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3621  only label the X axis, not both the X and Y axes. x: Label the X\n\
3622  axis.\n\
3623  y: Label the Y axis.\n\
3624  z: Label the Z axis.\n\
3625  p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3626  For X it is the axis that starts at y-min. For Y it is the\n\
3627  axis that starts at x-min.\n\
3628  s: Label the secondary axis.\n\
3629  v: Draw the text perpendicular to the axis.\n\
3630 \n\
3631 \n\
3632  disp (PLFLT, input) : Position of the reference point of string,\n\
3633  measured outwards from the specified viewport edge in units of the\n\
3634  current character height. Use negative disp to write within the\n\
3635  viewport.\n\
3636 \n\
3637  pos (PLFLT, input) : Position of the reference point of string\n\
3638  along the specified edge, expressed as a fraction of the length of\n\
3639  the edge.\n\
3640 \n\
3641  just (PLFLT, input) : Specifies the position of the string relative\n\
3642  to its reference point. If just=0. , the reference point is at\n\
3643  the left and if just=1. , it is at the right of the string. Other\n\
3644  values of just give intermediate justifications.\n\
3645 \n\
3646  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3647  written out.\n\
3648 ";
3649 static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3650 Set semitransparent cmap1 RGBA colors.\n\
3651 \n\
3652 DESCRIPTION:\n\
3653 \n\
3654  Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3655  RGBA vector values. This function also sets the number of cmap1\n\
3656  colors. N.B. Continuous cmap1 colors are indexed with a\n\
3657  floating-point index in the range from 0.0-1.0 which is linearly\n\
3658  transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3659  vectors in the range from 0 to\n\
3660  ncol1-1. So in order for this continuous color model to work\n\
3661  properly, it is the responsibility of the user of plscmap1 to insure\n\
3662  that these RGBA vectors are continuous functions of their integer\n\
3663  indices.\n\
3664 \n\
3665  Redacted form: plscmap1a(r, g, b, alpha)\n\
3666 \n\
3667  This function is used in example 31.\n\
3668 \n\
3669 \n\
3670 \n\
3671 SYNOPSIS:\n\
3672 \n\
3673 plscmap1a(r, g, b, alpha, ncol1)\n\
3674 \n\
3675 ARGUMENTS:\n\
3676 \n\
3677  r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3678  8-bit integers in the range from 0-255) the degree of red in the\n\
3679  color as a continuous function of the integer index of the vector.\n\
3680 \n\
3681  g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3682  8-bit integers in the range from 0-255) the degree of green in the\n\
3683  color as a continuous function of the integer index of the vector.\n\
3684 \n\
3685  b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3686  8-bit integers in the range from 0-255) the degree of blue in the\n\
3687  color as a continuous function of the integer index of the vector.\n\
3688 \n\
3689  alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3690  values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3691  completely transparent and 1.0 corresponds to completely opaque)\n\
3692  the alpha transparency of the color as a continuous function of\n\
3693  the integer index of the vector.\n\
3694 \n\
3695  ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3696  vectors.\n\
3697 ";
3698 static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3699 Select standard viewport\n\
3700 \n\
3701 DESCRIPTION:\n\
3702 \n\
3703  Selects the largest viewport within the subpage that leaves a standard\n\
3704  margin (left-hand margin of eight character heights, and a margin\n\
3705  around the other three sides of five character heights).\n\
3706 \n\
3707  Redacted form: plvsta()\n\
3708 \n\
3709  This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3710 \n\
3711 \n\
3712 \n\
3713 SYNOPSIS:\n\
3714 \n\
3715 plvsta()\n\
3716 ";
3717 static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3718 Switch to graphics screen\n\
3719 \n\
3720 DESCRIPTION:\n\
3721 \n\
3722  Sets an interactive device to graphics mode, used in conjunction with\n\
3723  pltext to allow graphics and text to be interspersed. On a device\n\
3724  which supports separate text and graphics windows, this command causes\n\
3725  control to be switched to the graphics window. If already in graphics\n\
3726  mode, this command is ignored. It is also ignored on devices which\n\
3727  only support a single window or use a different method for shifting\n\
3728  focus. See also pltext.\n\
3729 \n\
3730  Redacted form: plgra()\n\
3731 \n\
3732  This function is used in example 1.\n\
3733 \n\
3734 \n\
3735 \n\
3736 SYNOPSIS:\n\
3737 \n\
3738 plgra()\n\
3739 ";
3740 static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3741 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3742 \n\
3743 DESCRIPTION:\n\
3744 \n\
3745  Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3746  (see the PLplot documentation) index. Overwrites the previous color\n\
3747  value for the given index and, thus, does not result in any additional\n\
3748  allocation of space for colors.\n\
3749 \n\
3750  This function is used in example 30.\n\
3751 \n\
3752 \n\
3753 \n\
3754 SYNOPSIS:\n\
3755 \n\
3756 plscol0a(icol0, r, g, b, alpha)\n\
3757 \n\
3758 ARGUMENTS:\n\
3759 \n\
3760  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3761  number of colors (which is set by default, by plscmap0n, or even\n\
3762  by plscmap0).\n\
3763 \n\
3764  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3765  degree of red in the color.\n\
3766 \n\
3767  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3768  degree of green in the color.\n\
3769 \n\
3770  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3771  degree of blue in the color.\n\
3772 \n\
3773  alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3774  (0.0-1.0).\n\
3775 ";
3776 static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3777 Set y axis parameters\n\
3778 \n\
3779 DESCRIPTION:\n\
3780 \n\
3781  Identical to plsxax, except that arguments are flags for y axis. See\n\
3782  the description of plsxax for more detail.\n\
3783 \n\
3784  Redacted form: plsyax(digmax, digits)\n\
3785 \n\
3786  This function is used in examples 1, 14, and 31.\n\
3787 \n\
3788 \n\
3789 \n\
3790 SYNOPSIS:\n\
3791 \n\
3792 plsyax(digmax, digits)\n\
3793 \n\
3794 ARGUMENTS:\n\
3795 \n\
3796  digmax (PLINT, input) : Variable to set the maximum number of\n\
3797  digits for the y axis. If nonzero, the printed label will be\n\
3798  switched to a floating-point representation when the number of\n\
3799  digits exceeds digmax.\n\
3800 \n\
3801  digits (PLINT, input) : Field digits value. Currently, changing\n\
3802  its value here has no effect since it is set only by plbox or\n\
3803  plbox3. However, the user may obtain its value after a call to\n\
3804  either of these functions by calling plgyax.\n\
3805 ";
3806 static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3807 Returns 8-bit RGB values for given color index from cmap0\n\
3808 \n\
3809 DESCRIPTION:\n\
3810 \n\
3811  Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3812  PLplot documentation). Values are negative if an invalid color id is\n\
3813  given.\n\
3814 \n\
3815  Redacted form: plgcol0(icol0, r, g, b)\n\
3816 \n\
3817  This function is used in example 2.\n\
3818 \n\
3819 \n\
3820 \n\
3821 SYNOPSIS:\n\
3822 \n\
3823 plgcol0(icol0, r, g, b)\n\
3824 \n\
3825 ARGUMENTS:\n\
3826 \n\
3827  icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3828 \n\
3829  r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3830  value.\n\
3831 \n\
3832  g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3833  value.\n\
3834 \n\
3835  b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3836  value.\n\
3837 ";
3838 static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3839 Set seed for internal random number generator.\n\
3840 \n\
3841 DESCRIPTION:\n\
3842 \n\
3843  Set the seed for the internal random number generator. See plrandd for\n\
3844  further details.\n\
3845 \n\
3846  Redacted form: plseed(seed)\n\
3847 \n\
3848  This function is used in example 21.\n\
3849 \n\
3850 \n\
3851 \n\
3852 SYNOPSIS:\n\
3853 \n\
3854 plseed(seed)\n\
3855 \n\
3856 ARGUMENTS:\n\
3857 \n\
3858  seed (unsigned int, input) : Seed for random number generator.\n\
3859 ";
3860 static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
3861 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3862 \n\
3863 DESCRIPTION:\n\
3864 \n\
3865  When the implementation is completed this variant of plot3dc (see that\n\
3866  function\'s documentation for more details) should be suitable for the\n\
3867  case where the area of the x, y coordinate grid where z is defined can\n\
3868  be non-rectangular. The implementation is incomplete so the last 4\n\
3869  parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3870  indexymax; are currently ignored and the functionality is otherwise\n\
3871  identical to that of plot3dc.\n\
3872 \n\
3873  Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3874  indexymin, indexymax)\n\
3875 \n\
3876 \n\
3877  This function is not used in any example.\n\
3878 \n\
3879 \n\
3880 \n\
3881 SYNOPSIS:\n\
3882 \n\
3883 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3884 \n\
3885 ARGUMENTS:\n\
3886 \n\
3887  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3888  which the function is evaluated.\n\
3889 \n\
3890  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3891  which the function is evaluated.\n\
3892 \n\
3893  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3894  plot. Should have dimensions of\n\
3895  nx by\n\
3896  ny.\n\
3897 \n\
3898  nx (PLINT, input) : Number of x values at which the function is\n\
3899  evaluated.\n\
3900 \n\
3901  ny (PLINT, input) : Number of y values at which the function is\n\
3902  evaluated.\n\
3903 \n\
3904  opt (PLINT, input) : Determines the way in which the surface is\n\
3905  represented. To specify more than one option just add the options,\n\
3906  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3907  showing z as a function of x for each value of y[j] .\n\
3908  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3909  for each value of x[i] .\n\
3910  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3911  at which function is defined.\n\
3912  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3913  the z value being plotted. The color is used from the current\n\
3914  cmap1.\n\
3915  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3916  using parameters\n\
3917  nlevel and\n\
3918  clevel.\n\
3919  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3920  the borders of the plotted function.\n\
3921 \n\
3922 \n\
3923  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3924  levels.\n\
3925 \n\
3926  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3927 \n\
3928  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3929  corresponds to the first x index where z is defined.\n\
3930 \n\
3931  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3932  which corresponds (by convention) to one more than the last x\n\
3933  index value where z is defined.\n\
3934 \n\
3935  indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3936  values which all must be ≥ 0. These values are the first y index\n\
3937  where z is defined for a particular x index in the range from\n\
3938  indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3939  indexxmax.\n\
3940 \n\
3941  indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3942  values which all must be ≤ ny. These values correspond (by\n\
3943  convention) to one more than the last y index where z is defined\n\
3944  for a particular x index in the range from indexxmin to indexxmax\n\
3945  - 1. The dimension of indexymax is indexxmax.\n\
3946 ";
3947 static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3948 Get output file name\n\
3949 \n\
3950 DESCRIPTION:\n\
3951 \n\
3952  Gets the current output file name, if applicable.\n\
3953 \n\
3954  Redacted form: plgfnam(fnam)\n\
3955 \n\
3956  This function is used in example 31.\n\
3957 \n\
3958 \n\
3959 \n\
3960 SYNOPSIS:\n\
3961 \n\
3962 plgfnam(fnam)\n\
3963 \n\
3964 ARGUMENTS:\n\
3965 \n\
3966  fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3967  (with preallocated length of 80 characters or more) containing the\n\
3968  file name.\n\
3969 ";
3970 static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3971 Specify window\n\
3972 \n\
3973 DESCRIPTION:\n\
3974 \n\
3975  Specify the window, i.e., the world coordinates of the edges of the\n\
3976  viewport.\n\
3977 \n\
3978  Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3979 \n\
3980  This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3981  29, and 31.\n\
3982 \n\
3983 \n\
3984 \n\
3985 SYNOPSIS:\n\
3986 \n\
3987 plwind(xmin, xmax, ymin, ymax)\n\
3988 \n\
3989 ARGUMENTS:\n\
3990 \n\
3991  xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3992  of the viewport.\n\
3993 \n\
3994  xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3995  of the viewport.\n\
3996 \n\
3997  ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3998  the viewport.\n\
3999 \n\
4000  ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
4001  viewport.\n\
4002 ";
4003 static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
4004 Set cmap1 colors using a piece-wise linear relationship\n\
4005 \n\
4006 DESCRIPTION:\n\
4007 \n\
4008  Set cmap1 colors using a piece-wise linear relationship between the\n\
4009  cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
4010  (see the PLplot documentation). May be called at any time.\n\
4011 \n\
4012  The idea here is to specify a number of control points that define the\n\
4013  mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
4014  these points, linear interpolation is used which gives a smooth\n\
4015  variation of color with intensity index. Any number of control points\n\
4016  may be specified, located at arbitrary positions, although typically 2\n\
4017  - 4 are enough. Another way of stating this is that we are traversing\n\
4018  a given number of lines through HLS or RGB space as we move through\n\
4019  cmap1 intensity indices. The control points at the minimum and\n\
4020  maximum position (0 and 1) must always be specified. By adding more\n\
4021  control points you can get more variation. One good technique for\n\
4022  plotting functions that vary about some expected average is to use an\n\
4023  additional 2 control points in the center (position ~= 0.5) that are\n\
4024  the same lightness as the background (typically white for paper\n\
4025  output, black for crt), and same hue as the boundary control points.\n\
4026  This allows the highs and lows to be very easily distinguished.\n\
4027 \n\
4028  Each control point must specify the cmap1 intensity index and the\n\
4029  associated three coordinates in HLS or RGB space. The first point\n\
4030  must correspond to position = 0, and the last to position = 1.\n\
4031 \n\
4032  If RGB colors are provided then the interpolation takes place in RGB\n\
4033  space and is trivial. However if HLS colors are provided then, because\n\
4034  of the circular nature of the color wheel for the hue coordinate, the\n\
4035  interpolation could be performed in either direction around the color\n\
4036  wheel. The default behaviour is for the hue to be linearly\n\
4037  interpolated ignoring this circular property of hue. So for example,\n\
4038  the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
4039  green and cyan. If instead you wish to interpolate the other way\n\
4040  around the color wheel you have two options. You may provide hues\n\
4041  outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
4042  for red the interpolation will proceed via magenta. Alternatively you\n\
4043  can utilise the alt_hue_path variable to reverse the direction of\n\
4044  interpolation if you need to provide hues within the [0-360) range.\n\
4045 \n\
4046  Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
4047  240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
4048  -120]falsegreen-yellow-red-magenta-blue[240\n\
4049  480]falseblue-magenta-red-yellow-green[120\n\
4050  240]truegreen-yellow-red-magenta-blue[240\n\
4051  120]trueblue-magenta-red-yellow-green\n\
4052 \n\
4053  Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
4054  1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
4055  1]magnitudeHLSsaturation[0, 1]magnitude\n\
4056 \n\
4057  Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
4058  alt_hue_path)\n\
4059 \n\
4060  This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
4061 \n\
4062 \n\
4063 \n\
4064 SYNOPSIS:\n\
4065 \n\
4066 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
4067 \n\
4068 ARGUMENTS:\n\
4069 \n\
4070  itype (PLBOOL, input) : true: RGB, false: HLS.\n\
4071 \n\
4072  npts (PLINT, input) : number of control points\n\
4073 \n\
4074  intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
4075  intensity index (0.0-1.0) in ascending order for each control\n\
4076  point.\n\
4077 \n\
4078  coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
4079  coordinate (H or R) for each control point.\n\
4080 \n\
4081  coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
4082  coordinate (L or G) for each control point.\n\
4083 \n\
4084  coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
4085  coordinate (S or B) for each control point.\n\
4086 \n\
4087  alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
4088  npts - 1 elements), each containing either true to use the reversed\n\
4089  HLS interpolation or false to use the regular HLS interpolation.\n\
4090  (alt_hue_path[i] refers to the interpolation interval between the\n\
4091  i and i + 1 control points). This parameter is not used for RGB\n\
4092  colors (\n\
4093  itype = true).\n\
4094 ";
4095 static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
4096 Set the pause (on end-of-page) status\n\
4097 \n\
4098 DESCRIPTION:\n\
4099 \n\
4100  Set the pause (on end-of-page) status.\n\
4101 \n\
4102  Redacted form: plspause(pause)\n\
4103 \n\
4104  This function is in examples 14,20.\n\
4105 \n\
4106 \n\
4107 \n\
4108 SYNOPSIS:\n\
4109 \n\
4110 plspause(pause)\n\
4111 \n\
4112 ARGUMENTS:\n\
4113 \n\
4114  pause (PLBOOL, input) : If pause is true there will be a pause on\n\
4115  end-of-page for those drivers which support this. Otherwise there\n\
4116  is no pause.\n\
4117 ";
4118 static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
4119 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
4120 \n\
4121 DESCRIPTION:\n\
4122 \n\
4123  Routine for creating a discrete plot legend with a plotted filled box,\n\
4124  line, and/or line of symbols for each annotated legend entry. (See\n\
4125  plcolorbar for similar functionality for creating continuous color\n\
4126  bars.) The arguments of pllegend provide control over the location\n\
4127  and size of the legend as well as the location and characteristics of\n\
4128  the elements (most of which are optional) within that legend. The\n\
4129  resulting legend is clipped at the boundaries of the current subpage.\n\
4130  (N.B. the adopted coordinate system used for some of the parameters is\n\
4131  defined in the documentation of the position parameter.)\n\
4132 \n\
4133  Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
4134  position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
4135  ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
4136  test_justification, text_colors, text, box_colors, box_patterns,\n\
4137  box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
4138  symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
4139 \n\
4140  This function is used in examples 4, 26, and 33.\n\
4141 \n\
4142 \n\
4143 \n\
4144 SYNOPSIS:\n\
4145 \n\
4146 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\
4147 \n\
4148 ARGUMENTS:\n\
4149 \n\
4150  p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4151  legend width in adopted coordinates. This quantity is calculated\n\
4152  from plot_width, text_offset, ncolumn (possibly modified inside\n\
4153  the routine depending on nlegend and nrow), and the length\n\
4154  (calculated internally) of the longest text string.\n\
4155 \n\
4156  p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4157  legend height in adopted coordinates. This quantity is calculated\n\
4158  from text_scale, text_spacing, and nrow (possibly modified inside\n\
4159  the routine depending on nlegend and nrow).\n\
4160 \n\
4161  opt (PLINT, input) : opt contains bits controlling the overall\n\
4162  legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
4163  on the left of the legend and the plotted area on the right.\n\
4164  Otherwise, put the text area on the right of the legend and the\n\
4165  plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
4166  plot a (semitransparent) background for the legend. If the\n\
4167  PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
4168  legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
4169  possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
4170  plot the resulting array of legend entries in row-major order.\n\
4171  Otherwise, plot the legend entries in column-major order.\n\
4172 \n\
4173  position (PLINT, input) : position contains bits which control the\n\
4174  overall position of the legend and the definition of the adopted\n\
4175  coordinates used for positions just like what is done for the\n\
4176  position argument for plcolorbar. However, note that the defaults\n\
4177  for the position bits (see below) are different than the\n\
4178  plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
4179  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
4180  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
4181  the 16 possible standard positions (the 4 corners and centers of\n\
4182  the 4 sides for both the inside and outside cases) of the legend\n\
4183  relative to the adopted coordinate system. The corner positions\n\
4184  are specified by the appropriate combination of two of the\n\
4185  PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
4186  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
4187  value of one of those bits. The adopted coordinates are\n\
4188  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
4189  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
4190  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
4191  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
4192  then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
4193  If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
4194  use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
4195  PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
4196 \n\
4197  x (PLFLT, input) : X offset of the legend position in adopted\n\
4198  coordinates from the specified standard position of the legend.\n\
4199  For positive x, the direction of motion away from the standard\n\
4200  position is inward/outward from the standard corner positions or\n\
4201  standard left or right positions if the\n\
4202  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
4203  For the standard top or bottom positions, the direction of motion\n\
4204  is toward positive X.\n\
4205 \n\
4206  y (PLFLT, input) : Y offset of the legend position in adopted\n\
4207  coordinates from the specified standard position of the legend.\n\
4208  For positive y, the direction of motion away from the standard\n\
4209  position is inward/outward from the standard corner positions or\n\
4210  standard top or bottom positions if the\n\
4211  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
4212  the standard left or right positions, the direction of motion is\n\
4213  toward positive Y.\n\
4214 \n\
4215  plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
4216  of the plot area (where the colored boxes, lines, and/or lines of\n\
4217  symbols are drawn) of the legend.\n\
4218 \n\
4219  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
4220  legend (PL_LEGEND_BACKGROUND).\n\
4221 \n\
4222  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
4223  for the legend (PL_LEGEND_BOUNDING_BOX).\n\
4224 \n\
4225  bb_style (PLINT, input) : The pllsty style number for the\n\
4226  bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
4227 \n\
4228  nrow (PLINT, input) : The number of rows in the matrix used to\n\
4229  render the\n\
4230  nlegend legend entries. For internal transformations of\n\
4231  nrow, see further remarks under\n\
4232  nlegend.\n\
4233 \n\
4234  ncolumn (PLINT, input) : The number of columns in the matrix used\n\
4235  to render the\n\
4236  nlegend legend entries. For internal transformations of\n\
4237  ncolumn, see further remarks under\n\
4238  nlegend.\n\
4239 \n\
4240  nlegend (PLINT, input) : Number of legend entries. The above\n\
4241  nrow and\n\
4242  ncolumn values are transformed internally to be consistent with\n\
4243  nlegend. If either\n\
4244  nrow or\n\
4245  ncolumn is non-positive it is replaced by 1. If the resulting product\n\
4246  of\n\
4247  nrow and\n\
4248  ncolumn is less than\n\
4249  nlegend, the smaller of the two (or\n\
4250  nrow, if\n\
4251  nrow ==\n\
4252  ncolumn) is increased so the product is >=\n\
4253  nlegend. Thus, for example, the common\n\
4254  nrow = 0,\n\
4255  ncolumn = 0 case is transformed internally to\n\
4256  nrow =\n\
4257  nlegend,\n\
4258  ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
4259  column.\n\
4260 \n\
4261  opt_array (PLINT_VECTOR, input) : A vector of\n\
4262  nlegend values of options to control each individual plotted area\n\
4263  corresponding to a legend entry. If the\n\
4264  PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
4265  area. If the\n\
4266  PL_LEGEND_COLOR_BOX,\n\
4267  PL_LEGEND_LINE, and/or\n\
4268  PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
4269  entry is plotted with a colored box; a line; and/or a line of\n\
4270  symbols.\n\
4271 \n\
4272  text_offset (PLFLT, input) : Offset of the text area from the plot\n\
4273  area in units of character width.\n\
4274 \n\
4275  text_scale (PLFLT, input) : Character height scale for text\n\
4276  annotations.\n\
4277 \n\
4278  text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
4279  character height from one legend entry to the next.\n\
4280 \n\
4281  text_justification (PLFLT, input) : Justification parameter used\n\
4282  for text justification. The most common values of\n\
4283  text_justification are 0., 0.5, or 1. corresponding to a text that\n\
4284  is left justified, centred, or right justified within the text\n\
4285  area, but other values are allowed as well.\n\
4286 \n\
4287  text_colors (PLINT_VECTOR, input) : A vector containing\n\
4288  nlegend cmap0 text colors.\n\
4289 \n\
4290  text (PLCHAR_MATRIX, input) : A vector of\n\
4291  nlegend UTF-8 character strings containing the legend annotations.\n\
4292 \n\
4293  box_colors (PLINT_VECTOR, input) : A vector containing\n\
4294  nlegend cmap0 colors for the discrete colored boxes (\n\
4295  PL_LEGEND_COLOR_BOX).\n\
4296 \n\
4297  box_patterns (PLINT_VECTOR, input) : A vector containing\n\
4298  nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
4299  PL_LEGEND_COLOR_BOX).\n\
4300 \n\
4301  box_scales (PLFLT_VECTOR, input) : A vector containing\n\
4302  nlegend scales (units of fraction of character height) for the height\n\
4303  of the discrete colored boxes (\n\
4304  PL_LEGEND_COLOR_BOX).\n\
4305 \n\
4306  box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4307  nlegend line widths for the patterns specified by box_patterns (\n\
4308  PL_LEGEND_COLOR_BOX).\n\
4309 \n\
4310  line_colors (PLINT_VECTOR, input) : A vector containing\n\
4311  nlegend cmap0 line colors (\n\
4312  PL_LEGEND_LINE).\n\
4313 \n\
4314  line_styles (PLINT_VECTOR, input) : A vector containing\n\
4315  nlegend line styles (plsty indices) (\n\
4316  PL_LEGEND_LINE).\n\
4317 \n\
4318  line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4319  nlegend line widths (\n\
4320  PL_LEGEND_LINE).\n\
4321 \n\
4322  symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
4323  nlegend cmap0 symbol colors (\n\
4324  PL_LEGEND_SYMBOL).\n\
4325 \n\
4326  symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
4327  nlegend scale values for the symbol height (\n\
4328  PL_LEGEND_SYMBOL).\n\
4329 \n\
4330  symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
4331  nlegend numbers of symbols to be drawn across the width of the plotted\n\
4332  area (\n\
4333  PL_LEGEND_SYMBOL).\n\
4334 \n\
4335  symbols (PLCHAR_MATRIX, input) : A vector of\n\
4336  nlegend UTF-8 character strings containing the legend symbols. (\n\
4337  PL_LEGEND_SYMBOL).\n\
4338 ";
4339 static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
4340 Set number of colors in cmap1\n\
4341 \n\
4342 DESCRIPTION:\n\
4343 \n\
4344  Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
4345  values if this is the first allocation (see the PLplot documentation).\n\
4346 \n\
4347  Redacted form: plscmap1n(ncol1)\n\
4348 \n\
4349  This function is used in examples 8, 11, 20, and 21.\n\
4350 \n\
4351 \n\
4352 \n\
4353 SYNOPSIS:\n\
4354 \n\
4355 plscmap1n(ncol1)\n\
4356 \n\
4357 ARGUMENTS:\n\
4358 \n\
4359  ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
4360  the cmap1 palette. If this number is zero or less, then the value\n\
4361  from the previous call to plscmap1n is used and if there is no\n\
4362  previous call, then a default value is used.\n\
4363 ";
4364 static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
4365 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
4366 \n\
4367 DESCRIPTION:\n\
4368 \n\
4369  Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
4370  (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
4371  Values are negative if an invalid color id is given.\n\
4372 \n\
4373  Redacted form: plgcola(r, g, b)\n\
4374 \n\
4375  This function is used in example 30.\n\
4376 \n\
4377 \n\
4378 \n\
4379 SYNOPSIS:\n\
4380 \n\
4381 plgcol0a(icol0, r, g, b, alpha)\n\
4382 \n\
4383 ARGUMENTS:\n\
4384 \n\
4385  icol0 (PLINT, input) : Index of desired cmap0 color.\n\
4386 \n\
4387  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
4388  in the range from 0 to 255.\n\
4389 \n\
4390  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
4391  in the range from 0 to 255.\n\
4392 \n\
4393  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
4394  in the range from 0 to 255.\n\
4395 \n\
4396  alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
4397  transparency in the range from (0.0-1.0).\n\
4398 ";
4399 static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
4400 Replays contents of plot buffer to current device/file\n\
4401 \n\
4402 DESCRIPTION:\n\
4403 \n\
4404  Replays contents of plot buffer to current device/file.\n\
4405 \n\
4406  Redacted form: plreplot()\n\
4407 \n\
4408  This function is used in example 1,20.\n\
4409 \n\
4410 \n\
4411 \n\
4412 SYNOPSIS:\n\
4413 \n\
4414 plreplot()\n\
4415 ";
4416 static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
4417 Simple routine to write labels\n\
4418 \n\
4419 DESCRIPTION:\n\
4420 \n\
4421  Routine for writing simple labels. Use plmtex for more complex labels.\n\
4422 \n\
4423  Redacted form: pllab(xlabel, ylabel, tlabel)\n\
4424 \n\
4425  This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
4426 \n\
4427 \n\
4428 \n\
4429 SYNOPSIS:\n\
4430 \n\
4431 pllab(xlabel, ylabel, tlabel)\n\
4432 \n\
4433 ARGUMENTS:\n\
4434 \n\
4435  xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4436  the label for the x axis.\n\
4437 \n\
4438  ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4439  the label for the y axis.\n\
4440 \n\
4441  tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4442  the title of the plot.\n\
4443 ";
4444 static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
4445 Set parameters that define current device-space window\n\
4446 \n\
4447 DESCRIPTION:\n\
4448 \n\
4449  Set relative margin width, aspect ratio, and relative justification\n\
4450  that define current device-space window. If you want to just use the\n\
4451  previous value for any of these, just pass in the magic value\n\
4452  PL_NOTSET. It is unlikely that one should ever need to change the\n\
4453  aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4454  called the default values of mar, jx, and jy are all 0. aspect is set\n\
4455  to a device-specific value.\n\
4456 \n\
4457  Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4458 \n\
4459  This function is used in example 31.\n\
4460 \n\
4461 \n\
4462 \n\
4463 SYNOPSIS:\n\
4464 \n\
4465 plsdidev(mar, aspect, jx, jy)\n\
4466 \n\
4467 ARGUMENTS:\n\
4468 \n\
4469  mar (PLFLT, input) : Relative margin width.\n\
4470 \n\
4471  aspect (PLFLT, input) : Aspect ratio.\n\
4472 \n\
4473  jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4474  the range -0.5 to 0.5.\n\
4475 \n\
4476  jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4477  the range -0.5 to 0.5.\n\
4478 ";
4479 static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
4480 Begin a new page\n\
4481 \n\
4482 DESCRIPTION:\n\
4483 \n\
4484  Begins a new page. For a file driver, the output file is opened if\n\
4485  necessary. Advancing the page via pleop and plbop is useful when a\n\
4486  page break is desired at a particular point when plotting to subpages.\n\
4487  Another use for pleop and plbop is when plotting pages to different\n\
4488  files, since you can manually set the file name by calling plsfnam\n\
4489  after the call to pleop. (In fact some drivers may only support a\n\
4490  single page per file, making this a necessity.) One way to handle\n\
4491  this case automatically is to page advance via pladv, but enable\n\
4492  familying (see plsfam) with a small limit on the file size so that a\n\
4493  new family member file will be created on each page break.\n\
4494 \n\
4495  Redacted form: plbop()\n\
4496 \n\
4497  This function is used in examples 2 and 20.\n\
4498 \n\
4499 \n\
4500 \n\
4501 SYNOPSIS:\n\
4502 \n\
4503 plbop()\n\
4504 ";
4505 static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
4506 Set cmap0 colors by 8-bit RGB values\n\
4507 \n\
4508 DESCRIPTION:\n\
4509 \n\
4510  Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4511  documentation). This sets the entire color map -- only as many colors\n\
4512  as specified will be allocated.\n\
4513 \n\
4514  Redacted form: plscmap0(r, g, b)\n\
4515 \n\
4516  This function is used in examples 2 and 24.\n\
4517 \n\
4518 \n\
4519 \n\
4520 SYNOPSIS:\n\
4521 \n\
4522 plscmap0(r, g, b, ncol0)\n\
4523 \n\
4524 ARGUMENTS:\n\
4525 \n\
4526  r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4527  integers (0-255) representing the degree of red in the color.\n\
4528 \n\
4529  g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4530  integers (0-255) representing the degree of green in the color.\n\
4531 \n\
4532  b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4533  integers (0-255) representing the degree of blue in the color.\n\
4534 \n\
4535  ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4536 ";
4537 static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
4538 Set the number of subpages in x and y\n\
4539 \n\
4540 DESCRIPTION:\n\
4541 \n\
4542  Set the number of subpages in x and y.\n\
4543 \n\
4544  Redacted form: plssub(nx, ny)\n\
4545 \n\
4546  This function is examples 1,2,14,21,25,27.\n\
4547 \n\
4548 \n\
4549 \n\
4550 SYNOPSIS:\n\
4551 \n\
4552 plssub(nx, ny)\n\
4553 \n\
4554 ARGUMENTS:\n\
4555 \n\
4556  nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4557  of window columns).\n\
4558 \n\
4559  ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4560  of window rows).\n\
4561 ";
4562 static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
4563 Set a global coordinate transform function\n\
4564 \n\
4565 DESCRIPTION:\n\
4566 \n\
4567  This function can be used to define a coordinate transformation which\n\
4568  affects all elements drawn within the current plot window. The\n\
4569  coordinate_transform callback function is similar to that provided for\n\
4570  the plmap and plmeridians functions. The coordinate_transform_data\n\
4571  parameter may be used to pass extra data to coordinate_transform.\n\
4572 \n\
4573  Redacted form: General: plstransform(coordinate_transform,\n\
4574  coordinate_transform_data)\n\
4575 \n\
4576 \n\
4577  This function is used in examples 19 and 22.\n\
4578 \n\
4579 \n\
4580 \n\
4581 SYNOPSIS:\n\
4582 \n\
4583 plstransform(coordinate_transform, coordinate_transform_data)\n\
4584 \n\
4585 ARGUMENTS:\n\
4586 \n\
4587  coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4588  function that defines the transformation from the input (x, y)\n\
4589  world coordinates to new PLplot world coordinates. If\n\
4590  coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4591  case), then no transform is applied.\n\
4592 \n\
4593  coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4594  for\n\
4595  coordinate_transform.\n\
4596 ";
4597 static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
4598 Set opaque RGB cmap1 colors values\n\
4599 \n\
4600 DESCRIPTION:\n\
4601 \n\
4602  Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4603  vector values. This function also sets the number of cmap1 colors.\n\
4604  N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4605  in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4606  plcol1) to an integer index of these RGB vectors in the range from 0\n\
4607  to\n\
4608  ncol1-1. So in order for this continuous color model to work\n\
4609  properly, it is the responsibility of the user of plscmap1 to insure\n\
4610  that these RGB vectors are continuous functions of their integer\n\
4611  indices.\n\
4612 \n\
4613  Redacted form: plscmap1(r, g, b)\n\
4614 \n\
4615  This function is used in example 31.\n\
4616 \n\
4617 \n\
4618 \n\
4619 SYNOPSIS:\n\
4620 \n\
4621 plscmap1(r, g, b, ncol1)\n\
4622 \n\
4623 ARGUMENTS:\n\
4624 \n\
4625  r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4626  8-bit integers in the range from 0-255) the degree of red in the\n\
4627  color as a continuous function of the integer index of the vector.\n\
4628 \n\
4629  g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4630  8-bit integers in the range from 0-255) the degree of green in the\n\
4631  color as a continuous function of the integer index of the vector.\n\
4632 \n\
4633  b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4634  8-bit integers in the range from 0-255) the degree of blue in the\n\
4635  color as a continuous function of the integer index of the vector.\n\
4636 \n\
4637  ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4638 ";
4639 static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
4640 Configure the transformation between continuous and broken-down time for the current stream\n\
4641 \n\
4642 DESCRIPTION:\n\
4643 \n\
4644  Configure the transformation between continuous and broken-down time\n\
4645  for the current stream. This transformation is used by both plbtime\n\
4646  and plctime.\n\
4647 \n\
4648  Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4649  ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4650 \n\
4651 \n\
4652  This function is used in example 29.\n\
4653 \n\
4654 \n\
4655 \n\
4656 SYNOPSIS:\n\
4657 \n\
4658 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4659 \n\
4660 ARGUMENTS:\n\
4661 \n\
4662  scale (PLFLT, input) : The number of days per continuous time unit.\n\
4663  As a special case, if\n\
4664  scale is 0., then all other arguments are ignored, and the result (the\n\
4665  default used by PLplot) is the equivalent of a call to\n\
4666  plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4667  That is, for this special case broken-down time is calculated with\n\
4668  the proleptic Gregorian calendar with no leap seconds inserted,\n\
4669  and the continuous time is defined as the number of seconds since\n\
4670  the Unix epoch of 1970-01-01T00:00:00Z.\n\
4671 \n\
4672  offset1 (PLFLT, input) : If\n\
4673  ifbtime_offset is true, the parameters\n\
4674  offset1 and\n\
4675  offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4676  (with units in days) specify the epoch of the continuous time\n\
4677  relative to the MJD epoch corresponding to the Gregorian calendar\n\
4678  date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4679  are used to specify the origin to allow users (by specifying\n\
4680  offset1 as an integer that can be exactly represented by a\n\
4681  floating-point variable and specifying\n\
4682  offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4683  the numerical errors of the continuous time representation.\n\
4684 \n\
4685  offset2 (PLFLT, input) : See documentation of\n\
4686  offset1.\n\
4687 \n\
4688  ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4689  transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4690  calendar is used for broken-down time rather than the proleptic\n\
4691  Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4692  have been historically used to define UTC are inserted into the\n\
4693  broken-down time. Other possibilities for additional control bits\n\
4694  for ccontrol exist such as making the historical time corrections\n\
4695  in the broken-down time corresponding to ET (ephemeris time) or\n\
4696  making the (slightly non-constant) corrections from international\n\
4697  atomic time (TAI) to what astronomers define as terrestrial time\n\
4698  (TT). But those additional possibilities have not been\n\
4699  implemented yet in the qsastime library (one of the PLplot utility\n\
4700  libraries).\n\
4701 \n\
4702  ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4703  epoch of the continuous time scale is specified by the user. If\n\
4704  ifbtime_offset is false, then\n\
4705  offset1 and\n\
4706  offset2 are used to specify the epoch, and the following broken-down\n\
4707  time parameters are completely ignored. If\n\
4708  ifbtime_offset is true, then\n\
4709  offset1 and\n\
4710  offset2 are completely ignored, and the following broken-down time\n\
4711  parameters are used to specify the epoch.\n\
4712 \n\
4713  year (PLINT, input) : Year of epoch.\n\
4714 \n\
4715  month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4716  11 (December).\n\
4717 \n\
4718  day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4719 \n\
4720  hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4721 \n\
4722  min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4723 \n\
4724  sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4725 ";
4726 static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
4727 Set length of minor ticks\n\
4728 \n\
4729 DESCRIPTION:\n\
4730 \n\
4731  This sets up the length of the minor ticks and the length of the\n\
4732  terminals on error bars. The actual length is the product of the\n\
4733  default length and a scaling factor as for character height.\n\
4734 \n\
4735  Redacted form: plsmin(def, scale)\n\
4736 \n\
4737  This function is used in example 29.\n\
4738 \n\
4739 \n\
4740 \n\
4741 SYNOPSIS:\n\
4742 \n\
4743 plsmin(def, scale)\n\
4744 \n\
4745 ARGUMENTS:\n\
4746 \n\
4747  def (PLFLT, input) : The default length of a minor tick in\n\
4748  millimeters, should be set to zero if the default length is to\n\
4749  remain unchanged.\n\
4750 \n\
4751  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4752  actual tick length.\n\
4753 ";
4754 static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
4755 Set character size\n\
4756 \n\
4757 DESCRIPTION:\n\
4758 \n\
4759  This sets up the size of all subsequent characters drawn. The actual\n\
4760  height of a character is the product of the default character size and\n\
4761  a scaling factor.\n\
4762 \n\
4763  Redacted form: plschr(def, scale)\n\
4764 \n\
4765  This function is used in examples 2, 13, 23, and 24.\n\
4766 \n\
4767 \n\
4768 \n\
4769 SYNOPSIS:\n\
4770 \n\
4771 plschr(def, scale)\n\
4772 \n\
4773 ARGUMENTS:\n\
4774 \n\
4775  def (PLFLT, input) : The default height of a character in\n\
4776  millimeters, should be set to zero if the default height is to\n\
4777  remain unchanged. For rasterized drivers the dx and dy values\n\
4778  specified in plspage are used to convert from mm to pixels (note\n\
4779  the different unit systems used). This dpi aware scaling is not\n\
4780  implemented for all drivers yet.\n\
4781 \n\
4782  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4783  actual character height.\n\
4784 ";
4785 static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4786 Initialize PLplot\n\
4787 \n\
4788 DESCRIPTION:\n\
4789 \n\
4790  Initializing the plotting package. The program prompts for the device\n\
4791  keyword or number of the desired output device. Hitting a RETURN in\n\
4792  response to the prompt is the same as selecting the first device.\n\
4793  plinit will issue no prompt if either the device was specified\n\
4794  previously (via command line flag, the plsetopt function, or the\n\
4795  plsdev function), or if only one device is enabled when PLplot is\n\
4796  installed. If subpages have been specified, the output device is\n\
4797  divided into nx by ny subpages, each of which may be used\n\
4798  independently. If plinit is called again during a program, the\n\
4799  previously opened file will be closed. The subroutine pladv is used\n\
4800  to advance from one subpage to the next.\n\
4801 \n\
4802  Redacted form: plinit()\n\
4803 \n\
4804  This function is used in all of the examples.\n\
4805 \n\
4806 \n\
4807 \n\
4808 SYNOPSIS:\n\
4809 \n\
4810 plinit()\n\
4811 ";
4812 static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4813 Draw a box with axes, etc\n\
4814 \n\
4815 DESCRIPTION:\n\
4816 \n\
4817  Draws a box around the currently defined viewport, and labels it with\n\
4818  world coordinate values appropriate to the window. Thus plbox should\n\
4819  only be called after defining both viewport and window. The ascii\n\
4820  character strings xopt and yopt specify how the box should be drawn as\n\
4821  described below. If ticks and/or subticks are to be drawn for a\n\
4822  particular axis, the tick intervals and number of subintervals may be\n\
4823  specified explicitly, or they may be defaulted by setting the\n\
4824  appropriate arguments to zero.\n\
4825 \n\
4826  Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4827 \n\
4828 \n\
4829  This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4830  and 29.\n\
4831 \n\
4832 \n\
4833 \n\
4834 SYNOPSIS:\n\
4835 \n\
4836 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4837 \n\
4838 ARGUMENTS:\n\
4839 \n\
4840  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4841  options for the x axis. The string can include any combination of\n\
4842  the following letters (upper or lower case) in any order: a: Draws\n\
4843  axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4844  (x=0).\n\
4845  b: Draws bottom (X) or left (Y) edge of frame.\n\
4846  c: Draws top (X) or right (Y) edge of frame.\n\
4847  d: Plot labels as date / time. Values are assumed to be\n\
4848  seconds since the epoch (as used by gmtime).\n\
4849  f: Always use fixed point numeric labels.\n\
4850  g: Draws a grid at the major tick interval.\n\
4851  h: Draws a grid at the minor tick interval.\n\
4852  i: Inverts tick marks, so they are drawn outwards, rather than\n\
4853  inwards.\n\
4854  l: Labels axis logarithmically. This only affects the labels,\n\
4855  not the data, and so it is necessary to compute the logarithms\n\
4856  of data points before passing them to any of the drawing\n\
4857  routines.\n\
4858  m: Writes numeric labels at major tick intervals in the\n\
4859  unconventional location (above box for X, right of box for Y).\n\
4860  n: Writes numeric labels at major tick intervals in the\n\
4861  conventional location (below box for X, left of box for Y).\n\
4862  o: Use custom labelling function to generate axis label text.\n\
4863  The custom labelling function can be defined with the\n\
4864  plslabelfunc command.\n\
4865  s: Enables subticks between major ticks, only valid if t is\n\
4866  also specified.\n\
4867  t: Draws major ticks.\n\
4868  u: Exactly like \"b\" except don\'t draw edge line.\n\
4869  w: Exactly like \"c\" except don\'t draw edge line.\n\
4870  x: Exactly like \"t\" (including the side effect of the\n\
4871  numerical labels for the major ticks) except exclude drawing\n\
4872  the major and minor tick marks.\n\
4873 \n\
4874 \n\
4875  xtick (PLFLT, input) : World coordinate interval between major\n\
4876  ticks on the x axis. If it is set to zero, PLplot automatically\n\
4877  generates a suitable tick interval.\n\
4878 \n\
4879  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4880  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4881  generates a suitable minor tick interval.\n\
4882 \n\
4883  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4884  options for the y axis. The string can include any combination of\n\
4885  the letters defined above for xopt, and in addition may contain:\n\
4886  v: Write numeric labels for the y axis parallel to the base of the\n\
4887  graph, rather than parallel to the axis.\n\
4888 \n\
4889 \n\
4890  ytick (PLFLT, input) : World coordinate interval between major\n\
4891  ticks on the y axis. If it is set to zero, PLplot automatically\n\
4892  generates a suitable tick interval.\n\
4893 \n\
4894  nysub (PLINT, input) : Number of subintervals between major y axis\n\
4895  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4896  generates a suitable minor tick interval.\n\
4897 ";
4898 static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4899 Get parameters that define current device-space window\n\
4900 \n\
4901 DESCRIPTION:\n\
4902 \n\
4903  Get relative margin width, aspect ratio, and relative justification\n\
4904  that define current device-space window. If plsdidev has not been\n\
4905  called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4906  p_jy will all be 0.\n\
4907 \n\
4908  Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4909 \n\
4910  This function is used in example 31.\n\
4911 \n\
4912 \n\
4913 \n\
4914 SYNOPSIS:\n\
4915 \n\
4916 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4917 \n\
4918 ARGUMENTS:\n\
4919 \n\
4920  p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4921  margin width.\n\
4922 \n\
4923  p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4924  ratio.\n\
4925 \n\
4926  p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4927  justification in x.\n\
4928 \n\
4929  p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4930  justification in y.\n\
4931 ";
4932 static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4933 Plot a glyph at the specified points\n\
4934 \n\
4935 DESCRIPTION:\n\
4936 \n\
4937  Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4938  because many[!] more glyphs are accessible with plstring.) The glyph\n\
4939  is specified with a PLplot user string. Note that the user string is\n\
4940  not actually limited to one glyph so it is possible (but not normally\n\
4941  useful) to plot more than one glyph at the specified points with this\n\
4942  function. As with plmtex and plptex, the user string can contain FCI\n\
4943  escapes to determine the font, UTF-8 code to determine the glyph or\n\
4944  else PLplot escapes for Hershey or unicode text to determine the\n\
4945  glyph.\n\
4946 \n\
4947  Redacted form: plstring(x, y, string)\n\
4948 \n\
4949  This function is used in examples 4, 21 and 26.\n\
4950 \n\
4951 \n\
4952 \n\
4953 SYNOPSIS:\n\
4954 \n\
4955 plstring(n, x, y, string)\n\
4956 \n\
4957 ARGUMENTS:\n\
4958 \n\
4959  n (PLINT, input) : Number of points in the x and y vectors.\n\
4960 \n\
4961  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4962  the points.\n\
4963 \n\
4964  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4965  the points.\n\
4966 \n\
4967  string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4968  the glyph(s) to be plotted at each of the n points.\n\
4969 ";
4970 static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
4971 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4972 \n\
4973 DESCRIPTION:\n\
4974 \n\
4975  As per plmapline, however the items are plotted as strings or points\n\
4976  in the same way as plstring.\n\
4977 \n\
4978  Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4979  maxy, plotentries)\n\
4980 \n\
4981  This function is not used in any examples.\n\
4982 \n\
4983 \n\
4984 \n\
4985 SYNOPSIS:\n\
4986 \n\
4987 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4988 \n\
4989 ARGUMENTS:\n\
4990 \n\
4991  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4992  transform the coordinates given in the shapefile into a plot\n\
4993  coordinate system. By using this transform, we can change from a\n\
4994  longitude, latitude coordinate to a polar stereographic project,\n\
4995  for example. Initially, x[0]..[n-1] are the longitudes and\n\
4996  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4997  mapform(), x[] and y[] should be replaced by the corresponding\n\
4998  plot coordinates. If no transform is desired, mapform can be\n\
4999  replaced by NULL.\n\
5000 \n\
5001  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5002  the file name of a set of Shapefile files without the file\n\
5003  extension.\n\
5004 \n\
5005  string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5006  drawn.\n\
5007 \n\
5008  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
5009  be in the same units as used by the Shapefile. You could use a\n\
5010  very large negative number to plot everything, but you can improve\n\
5011  performance by limiting the area drawn. The units must match those\n\
5012  of the Shapefile projection, which may be for example longitude or\n\
5013  distance. The value of minx must be less than the value of maxx.\n\
5014 \n\
5015  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
5016  use a very large number to plot everything, but you can improve\n\
5017  performance by limiting the area drawn.\n\
5018 \n\
5019  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
5020  be in the same units as used by the Shapefile. You could use a\n\
5021  very large negative number to plot everything, but you can improve\n\
5022  performance by limiting the area drawn. The units must match those\n\
5023  of the Shapefile projection, which may be for example latitude or\n\
5024  distance. The value of miny must be less than the value of maxy.\n\
5025 \n\
5026  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
5027  use a very large number to plot everything, but you can improve\n\
5028  performance by limiting the area drawn.\n\
5029 \n\
5030  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
5031  zero-based indices of the Shapefile elements which will be drawn.\n\
5032  Setting\n\
5033  plotentries to NULL will plot all elements of the Shapefile.\n\
5034 \n\
5035  nplotentries (PLINT, input) : The number of items in\n\
5036  plotentries. Ignored if\n\
5037  plotentries is NULL.\n\
5038 ";
5039 static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
5040 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
5041 \n\
5042 DESCRIPTION:\n\
5043 \n\
5044  Sets up plotter environment for simple graphs by calling pladv and\n\
5045  setting up viewport and window to sensible default values. plenv0\n\
5046  leaves a standard margin (left-hand margin of eight character heights,\n\
5047  and a margin around the other three sides of five character heights)\n\
5048  around most graphs for axis labels and a title. When these defaults\n\
5049  are not suitable, use the individual routines plvpas, plvpor, or\n\
5050  plvasp for setting up the viewport, plwind for defining the window,\n\
5051  and plbox for drawing the box.\n\
5052 \n\
5053  Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
5054 \n\
5055  This function is used in example 21.\n\
5056 \n\
5057 \n\
5058 \n\
5059 SYNOPSIS:\n\
5060 \n\
5061 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
5062 \n\
5063 ARGUMENTS:\n\
5064 \n\
5065  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
5066  world coordinates).\n\
5067 \n\
5068  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
5069  world coordinates).\n\
5070 \n\
5071  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
5072  coordinates).\n\
5073 \n\
5074  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
5075  coordinates).\n\
5076 \n\
5077  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
5078  scales will not be set, the user must set up the scale before\n\
5079  calling plenv0 using plsvpa, plvasp or other.\n\
5080  0: the x and y axes are scaled independently to use as much of\n\
5081  the screen as possible.\n\
5082  1: the scales of the x and y axes are made equal.\n\
5083  2: the axis of the x and y axes are made equal, and the plot\n\
5084  box will be square.\n\
5085 \n\
5086 \n\
5087  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
5088  -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
5089  -1: draw box only.\n\
5090  0: draw box, ticks, and numeric tick labels.\n\
5091  1: also draw coordinate axes at x=0 and y=0.\n\
5092  2: also draw a grid at major tick positions in both\n\
5093  coordinates.\n\
5094  3: also draw a grid at minor tick positions in both\n\
5095  coordinates.\n\
5096  10: same as 0 except logarithmic x tick marks. (The x data\n\
5097  have to be converted to logarithms separately.)\n\
5098  11: same as 1 except logarithmic x tick marks. (The x data\n\
5099  have to be converted to logarithms separately.)\n\
5100  12: same as 2 except logarithmic x tick marks. (The x data\n\
5101  have to be converted to logarithms separately.)\n\
5102  13: same as 3 except logarithmic x tick marks. (The x data\n\
5103  have to be converted to logarithms separately.)\n\
5104  20: same as 0 except logarithmic y tick marks. (The y data\n\
5105  have to be converted to logarithms separately.)\n\
5106  21: same as 1 except logarithmic y tick marks. (The y data\n\
5107  have to be converted to logarithms separately.)\n\
5108  22: same as 2 except logarithmic y tick marks. (The y data\n\
5109  have to be converted to logarithms separately.)\n\
5110  23: same as 3 except logarithmic y tick marks. (The y data\n\
5111  have to be converted to logarithms separately.)\n\
5112  30: same as 0 except logarithmic x and y tick marks. (The x\n\
5113  and y data have to be converted to logarithms separately.)\n\
5114  31: same as 1 except logarithmic x and y tick marks. (The x\n\
5115  and y data have to be converted to logarithms separately.)\n\
5116  32: same as 2 except logarithmic x and y tick marks. (The x\n\
5117  and y data have to be converted to logarithms separately.)\n\
5118  33: same as 3 except logarithmic x and y tick marks. (The x\n\
5119  and y data have to be converted to logarithms separately.)\n\
5120  40: same as 0 except date / time x labels.\n\
5121  41: same as 1 except date / time x labels.\n\
5122  42: same as 2 except date / time x labels.\n\
5123  43: same as 3 except date / time x labels.\n\
5124  50: same as 0 except date / time y labels.\n\
5125  51: same as 1 except date / time y labels.\n\
5126  52: same as 2 except date / time y labels.\n\
5127  53: same as 3 except date / time y labels.\n\
5128  60: same as 0 except date / time x and y labels.\n\
5129  61: same as 1 except date / time x and y labels.\n\
5130  62: same as 2 except date / time x and y labels.\n\
5131  63: same as 3 except date / time x and y labels.\n\
5132  70: same as 0 except custom x and y labels.\n\
5133  71: same as 1 except custom x and y labels.\n\
5134  72: same as 2 except custom x and y labels.\n\
5135  73: same as 3 except custom x and y labels.\n\
5136 ";
5137 static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
5138 Configure the transformations required for projecting a 3D surface on a 2D window\n\
5139 \n\
5140 DESCRIPTION:\n\
5141 \n\
5142  Configure the transformations required for projecting a 3D surface on\n\
5143  an existing 2D window. Those transformations (see the PLplot\n\
5144  documentation) are done to a rectangular cuboid enclosing the 3D\n\
5145  surface which has its limits expressed in 3D world coordinates and\n\
5146  also normalized 3D coordinates (used for interpreting the altitude and\n\
5147  azimuth of the viewing angle). The transformations consist of the\n\
5148  linear transform from 3D world coordinates to normalized 3D\n\
5149  coordinates, and the 3D rotation of normalized coordinates required to\n\
5150  align the pole of the new 3D coordinate system with the viewing\n\
5151  direction specified by altitude and azimuth so that x and y of the\n\
5152  surface elements in that transformed coordinate system are the\n\
5153  projection of the 3D surface with given viewing direction on the 2D\n\
5154  window.\n\
5155 \n\
5156  The enclosing rectangular cuboid for the surface plot is defined by\n\
5157  xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
5158  mapped into the same rectangular cuboid with normalized 3D coordinate\n\
5159  sizes of basex by basey by height so that xmin maps to -\n\
5160  basex/2, xmax maps to basex/2, ymin maps to -\n\
5161  basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
5162  The resulting rectangular cuboid in normalized coordinates is then\n\
5163  viewed by an observer at altitude alt and azimuth az. This routine\n\
5164  must be called before plbox3 or any of the 3D surface plotting\n\
5165  routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
5166  plsurf3dl or plfill3.\n\
5167 \n\
5168  Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
5169  zmin, zmax, alt, az)\n\
5170 \n\
5171  This function is examples 8, 11, 18, and 21.\n\
5172 \n\
5173 \n\
5174 \n\
5175 SYNOPSIS:\n\
5176 \n\
5177 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
5178 \n\
5179 ARGUMENTS:\n\
5180 \n\
5181  basex (PLFLT, input) : The normalized x coordinate size of the\n\
5182  rectangular cuboid.\n\
5183 \n\
5184  basey (PLFLT, input) : The normalized y coordinate size of the\n\
5185  rectangular cuboid.\n\
5186 \n\
5187  height (PLFLT, input) : The normalized z coordinate size of the\n\
5188  rectangular cuboid.\n\
5189 \n\
5190  xmin (PLFLT, input) : The minimum x world coordinate of the\n\
5191  rectangular cuboid.\n\
5192 \n\
5193  xmax (PLFLT, input) : The maximum x world coordinate of the\n\
5194  rectangular cuboid.\n\
5195 \n\
5196  ymin (PLFLT, input) : The minimum y world coordinate of the\n\
5197  rectangular cuboid.\n\
5198 \n\
5199  ymax (PLFLT, input) : The maximum y world coordinate of the\n\
5200  rectangular cuboid.\n\
5201 \n\
5202  zmin (PLFLT, input) : The minimum z world coordinate of the\n\
5203  rectangular cuboid.\n\
5204 \n\
5205  zmax (PLFLT, input) : The maximum z world coordinate of the\n\
5206  rectangular cuboid.\n\
5207 \n\
5208  alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
5209  plane of the rectangular cuboid in normalized coordinates.\n\
5210 \n\
5211  az (PLFLT, input) : The viewing azimuth in degrees of the\n\
5212  rectangular cuboid in normalized coordinates. When az=0, the\n\
5213  observer is looking face onto the zx plane of the rectangular\n\
5214  cuboid in normalized coordinates, and as az is increased, the\n\
5215  observer moves clockwise around that cuboid when viewed from above\n\
5216  the xy plane.\n\
5217 ";
5218 static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
5219 Draw filled polygon\n\
5220 \n\
5221 DESCRIPTION:\n\
5222 \n\
5223  Fills the polygon defined by the n points (\n\
5224  x[i],\n\
5225  y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
5226  style is a solid fill. The routine will automatically close the\n\
5227  polygon between the last and first vertices. If multiple closed\n\
5228  polygons are passed in x and y then plfill will fill in between them.\n\
5229 \n\
5230  Redacted form: plfill(x,y)\n\
5231 \n\
5232  This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
5233 \n\
5234 \n\
5235 \n\
5236 SYNOPSIS:\n\
5237 \n\
5238 plfill(n, x, y)\n\
5239 \n\
5240 ARGUMENTS:\n\
5241 \n\
5242  n (PLINT, input) : Number of vertices in polygon.\n\
5243 \n\
5244  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5245  vertices.\n\
5246 \n\
5247  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5248  vertices.\n\
5249 ";
5250 static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
5251 Magnitude colored plot surface with contour\n\
5252 \n\
5253 DESCRIPTION:\n\
5254 \n\
5255  Aside from dropping the\n\
5256  side functionality this is a more powerful form of plot3d: the surface\n\
5257  mesh can be colored accordingly to the current z value being plotted,\n\
5258  a contour plot can be drawn at the base XY plane, and a curtain can be\n\
5259  drawn between the plotted function border and the base XY plane. The\n\
5260  arguments are identical to those of plmeshc. The only difference\n\
5261  between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
5262  the surface, while plot3dc only draws the surface as viewed from the\n\
5263  top.\n\
5264 \n\
5265  Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
5266 \n\
5267 \n\
5268  This function is used in example 21.\n\
5269 \n\
5270 \n\
5271 \n\
5272 SYNOPSIS:\n\
5273 \n\
5274 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
5275 \n\
5276 ARGUMENTS:\n\
5277 \n\
5278  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5279  which the function is evaluated.\n\
5280 \n\
5281  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5282  which the function is evaluated.\n\
5283 \n\
5284  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5285  plot. Should have dimensions of\n\
5286  nx by\n\
5287  ny.\n\
5288 \n\
5289  nx (PLINT, input) : Number of x values at which function is\n\
5290  evaluated.\n\
5291 \n\
5292  ny (PLINT, input) : Number of y values at which function is\n\
5293  evaluated.\n\
5294 \n\
5295  opt (PLINT, input) : Determines the way in which the surface is\n\
5296  represented. To specify more than one option just add the options,\n\
5297  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
5298  showing z as a function of x for each value of y[j] .\n\
5299  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5300  for each value of x[i] .\n\
5301  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5302  at which function is defined.\n\
5303  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
5304  the z value being plotted. The color is used from the current\n\
5305  cmap1.\n\
5306  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5307  using parameters\n\
5308  nlevel and\n\
5309  clevel.\n\
5310  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5311  the borders of the plotted function.\n\
5312 \n\
5313 \n\
5314  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5315  levels.\n\
5316 \n\
5317  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5318 ";
5319 static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
5320 Write text relative to viewport boundaries\n\
5321 \n\
5322 DESCRIPTION:\n\
5323 \n\
5324  Writes text at a specified position relative to the viewport\n\
5325  boundaries. Text may be written inside or outside the viewport, but\n\
5326  is clipped at the subpage boundaries. The reference point of a string\n\
5327  lies along a line passing through the string at half the height of a\n\
5328  capital letter. The position of the reference point along this line\n\
5329  is determined by just, and the position of the reference point\n\
5330  relative to the viewport is set by disp and pos.\n\
5331 \n\
5332  Redacted form: General: plmtex(side, disp, pos, just, text)\n\
5333 \n\
5334 \n\
5335  This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
5336  26.\n\
5337 \n\
5338 \n\
5339 \n\
5340 SYNOPSIS:\n\
5341 \n\
5342 plmtex(side, disp, pos, just, text)\n\
5343 \n\
5344 ARGUMENTS:\n\
5345 \n\
5346  side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5347  the side of the viewport along which the text is to be written.\n\
5348  The string must be one of: b: Bottom of viewport, text written\n\
5349  parallel to edge.\n\
5350  bv: Bottom of viewport, text written at right angles to edge.\n\
5351  l: Left of viewport, text written parallel to edge.\n\
5352  lv: Left of viewport, text written at right angles to edge.\n\
5353  r: Right of viewport, text written parallel to edge.\n\
5354  rv: Right of viewport, text written at right angles to edge.\n\
5355  t: Top of viewport, text written parallel to edge.\n\
5356  tv: Top of viewport, text written at right angles to edge.\n\
5357 \n\
5358 \n\
5359  disp (PLFLT, input) : Position of the reference point of string,\n\
5360  measured outwards from the specified viewport edge in units of the\n\
5361  current character height. Use negative disp to write within the\n\
5362  viewport.\n\
5363 \n\
5364  pos (PLFLT, input) : Position of the reference point of string\n\
5365  along the specified edge, expressed as a fraction of the length of\n\
5366  the edge.\n\
5367 \n\
5368  just (PLFLT, input) : Specifies the position of the string relative\n\
5369  to its reference point. If just=0. , the reference point is at\n\
5370  the left and if just=1. , it is at the right of the string. Other\n\
5371  values of just give intermediate justifications.\n\
5372 \n\
5373  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5374  written out.\n\
5375 ";
5376 static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
5377 Set arrow style for vector plots\n\
5378 \n\
5379 DESCRIPTION:\n\
5380 \n\
5381  Set the style for the arrow used by plvect to plot vectors.\n\
5382 \n\
5383  Redacted form: plsvect(arrowx, arrowy, fill)\n\
5384 \n\
5385  This function is used in example 22.\n\
5386 \n\
5387 \n\
5388 \n\
5389 SYNOPSIS:\n\
5390 \n\
5391 plsvect(arrowx, arrowy, npts, fill)\n\
5392 \n\
5393 ARGUMENTS:\n\
5394 \n\
5395  arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
5396  the x and y points which make up the arrow. The arrow is plotted\n\
5397  by joining these points to form a polygon. The scaling assumes\n\
5398  that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
5399  <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
5400  will be reset to its default.\n\
5401 \n\
5402  npts (PLINT, input) : Number of points in the vectors arrowx and\n\
5403  arrowy.\n\
5404 \n\
5405  fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
5406  fill is false then the arrow is open.\n\
5407 ";
5408 static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5409 Get family file parameters\n\
5410 \n\
5411 DESCRIPTION:\n\
5412 \n\
5413  Gets information about current family file, if familying is enabled.\n\
5414  See the PLplot documentation for more information.\n\
5415 \n\
5416  Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5417 \n\
5418  This function is used in examples 14 and 31.\n\
5419 \n\
5420 \n\
5421 \n\
5422 SYNOPSIS:\n\
5423 \n\
5424 plgfam(p_fam, p_num, p_bmax)\n\
5425 \n\
5426 ARGUMENTS:\n\
5427 \n\
5428  p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5429  family flag value. If nonzero, familying is enabled for the\n\
5430  current device.\n\
5431 \n\
5432  p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5433  family file number.\n\
5434 \n\
5435  p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5436  file size (in bytes) for a family file.\n\
5437 ";
5438 static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
5439 Random number generator returning a real random number in the range [0,1]\n\
5440 \n\
5441 DESCRIPTION:\n\
5442 \n\
5443  Random number generator returning a real random number in the range\n\
5444  [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5445  / compilers provide their own random number generator, and so this is\n\
5446  provided purely for convenience and to give a consistent random number\n\
5447  generator across all languages supported by PLplot. This is\n\
5448  particularly useful for comparing results from the test suite of\n\
5449  examples.\n\
5450 \n\
5451  Redacted form: plrandd()\n\
5452 \n\
5453  This function is used in examples 17 and 21.\n\
5454 \n\
5455 \n\
5456 \n\
5457 SYNOPSIS:\n\
5458 \n\
5459 plrandd()\n\
5460 ";
5461 static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5462 Contour plot\n\
5463 \n\
5464 DESCRIPTION:\n\
5465 \n\
5466  Draws a contour plot of the data in f[\n\
5467  nx][\n\
5468  ny], using the nlevel contour levels specified by clevel. Only the\n\
5469  region of the matrix from kx to lx and from ky to ly is plotted out\n\
5470  where all these index ranges are interpreted as one-based for\n\
5471  historical reasons. A transformation routine pointed to by pltr with\n\
5472  a generic pointer pltr_data for additional data required by the\n\
5473  transformation routine is used to map indices within the matrix to the\n\
5474  world coordinates.\n\
5475 \n\
5476  Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5477  where (see above discussion) the pltr, pltr_data callback arguments\n\
5478  are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5479  vectors; or xg and yg matrices.\n\
5480 \n\
5481  This function is used in examples 9, 14, 16, and 22.\n\
5482 \n\
5483 \n\
5484 \n\
5485 SYNOPSIS:\n\
5486 \n\
5487 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5488 \n\
5489 ARGUMENTS:\n\
5490 \n\
5491  f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5492 \n\
5493  nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5494 \n\
5495  kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5496  kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5497  zero-based for historical backwards-compatibility reasons.\n\
5498 \n\
5499  ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5500  ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5501  zero-based for historical backwards-compatibility reasons.\n\
5502 \n\
5503  clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5504  which to draw contours.\n\
5505 \n\
5506  nlevel (PLINT, input) : Number of contour levels to draw.\n\
5507 \n\
5508  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5509  defines the transformation between the zero-based indices of the\n\
5510  matrix f and the world coordinates.For the C case, transformation\n\
5511  functions are provided in the PLplot library: pltr0 for the\n\
5512  identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5513  respectively defined by vectors and matrices. In addition, C\n\
5514  callback routines for the transformation can be supplied by the\n\
5515  user such as the mypltr function in examples/c/x09c.c which\n\
5516  provides a general linear transformation between index coordinates\n\
5517  and world coordinates.For languages other than C you should\n\
5518  consult the PLplot documentation for the details concerning how\n\
5519  PLTRANSFORM_callback arguments are interfaced. However, in\n\
5520  general, a particular pattern of callback-associated arguments\n\
5521  such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5522  yg matrices are respectively interfaced to a linear-transformation\n\
5523  routine similar to the above mypltr function; pltr1; and pltr2.\n\
5524  Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5525  the PLplot documentation) support native language callbacks for\n\
5526  handling index to world-coordinate transformations. Examples of\n\
5527  these various approaches are given in examples/<language>x09*,\n\
5528  examples/<language>x16*, examples/<language>x20*,\n\
5529  examples/<language>x21*, and examples/<language>x22*, for all our\n\
5530  supported languages.\n\
5531 \n\
5532  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5533  information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5534  that is externally supplied.\n\
5535 ";
5536 static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
5537 Set line style\n\
5538 \n\
5539 DESCRIPTION:\n\
5540 \n\
5541  This sets up the line style for all lines subsequently drawn. A line\n\
5542  consists of segments in which the pen is alternately down and up. The\n\
5543  lengths of these segments are passed in the vectors mark and space\n\
5544  respectively. The number of mark-space pairs is specified by nms. In\n\
5545  order to return the line style to the default continuous line, plstyl\n\
5546  should be called with nms =0 .(see also pllsty)\n\
5547 \n\
5548  Redacted form: plstyl(mark, space)\n\
5549 \n\
5550  This function is used in examples 1, 9, and 14.\n\
5551 \n\
5552 \n\
5553 \n\
5554 SYNOPSIS:\n\
5555 \n\
5556 plstyl(nms, mark, space)\n\
5557 \n\
5558 ARGUMENTS:\n\
5559 \n\
5560  nms (PLINT, input) : The number of mark and space elements in a\n\
5561  line. Thus a simple broken line can be obtained by setting nms=1\n\
5562  . A continuous line is specified by setting nms=0 .\n\
5563 \n\
5564  mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5565  segments during which the pen is down, measured in micrometers.\n\
5566 \n\
5567  space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5568  the segments during which the pen is up, measured in micrometers.\n\
5569 ";
5570 static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
5571 Set the cmap0 palette using the specified cmap0*.pal format file\n\
5572 \n\
5573 DESCRIPTION:\n\
5574 \n\
5575  Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5576 \n\
5577  Redacted form: plspal0(filename)\n\
5578 \n\
5579  This function is in example 16.\n\
5580 \n\
5581 \n\
5582 \n\
5583 SYNOPSIS:\n\
5584 \n\
5585 plspal0(filename)\n\
5586 \n\
5587 ARGUMENTS:\n\
5588 \n\
5589  filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5590  containing the name of the cmap0*.pal file. If this string is\n\
5591  empty, use the default cmap0*.pal file.\n\
5592 ";
5593 static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
5594 Set the cmap1 palette using the specified cmap1*.pal format file\n\
5595 \n\
5596 DESCRIPTION:\n\
5597 \n\
5598  Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5599 \n\
5600  Redacted form: plspal1(filename, interpolate)\n\
5601 \n\
5602  This function is used in example 16.\n\
5603 \n\
5604 \n\
5605 \n\
5606 SYNOPSIS:\n\
5607 \n\
5608 plspal1(filename, interpolate)\n\
5609 \n\
5610 ARGUMENTS:\n\
5611 \n\
5612  filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5613  containing the name of the cmap1*.pal file. If this string is\n\
5614  empty, use the default cmap1*.pal file.\n\
5615 \n\
5616  interpolate (PLBOOL, input) : If this parameter is true, the\n\
5617  columns containing the intensity index, r, g, b, alpha and\n\
5618  alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5619  palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5620  a flag which controls whether the r, g, b data sent to plscmap1la\n\
5621  are interpreted as HLS or RGB.) If this parameter is false, the\n\
5622  intensity index and alt_hue_path columns are ignored and the r, g,\n\
5623  b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5624  are used instead to set the cmap1 palette directly with a call to\n\
5625  plscmap1a.\n\
5626 ";
5627 static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
5628 Set current output stream\n\
5629 \n\
5630 DESCRIPTION:\n\
5631 \n\
5632  Sets the number of the current output stream. The stream number\n\
5633  defaults to 0 unless changed by this routine. The first use of this\n\
5634  routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5635 \n\
5636  Redacted form: plsstrm(strm)\n\
5637 \n\
5638  This function is examples 1,14,20.\n\
5639 \n\
5640 \n\
5641 \n\
5642 SYNOPSIS:\n\
5643 \n\
5644 plsstrm(strm)\n\
5645 \n\
5646 ARGUMENTS:\n\
5647 \n\
5648  strm (PLINT, input) : The current stream number.\n\
5649 ";
5650 static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
5651 Specify viewport using normalized subpage coordinates\n\
5652 \n\
5653 DESCRIPTION:\n\
5654 \n\
5655  Device-independent routine for setting up the viewport. This defines\n\
5656  the viewport in terms of normalized subpage coordinates which run from\n\
5657  0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5658  current subpage. Use the alternate routine plsvpa in order to create\n\
5659  a viewport of a definite size.\n\
5660 \n\
5661  Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5662 \n\
5663  This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5664  24, 26, 27, and 31.\n\
5665 \n\
5666 \n\
5667 \n\
5668 SYNOPSIS:\n\
5669 \n\
5670 plvpor(xmin, xmax, ymin, ymax)\n\
5671 \n\
5672 ARGUMENTS:\n\
5673 \n\
5674  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5675  left-hand edge of the viewport.\n\
5676 \n\
5677  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5678  right-hand edge of the viewport.\n\
5679 \n\
5680  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5681  bottom edge of the viewport.\n\
5682 \n\
5683  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5684  edge of the viewport.\n\
5685 ";
5686 static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
5687 Write text inside the viewport\n\
5688 \n\
5689 DESCRIPTION:\n\
5690 \n\
5691  Writes text at a specified position and inclination within the\n\
5692  viewport. Text is clipped at the viewport boundaries. The reference\n\
5693  point of a string lies along a line passing through the string at half\n\
5694  the height of a capital letter. The position of the reference point\n\
5695  along this line is determined by just, the reference point is placed\n\
5696  at world coordinates (\n\
5697  x,\n\
5698  y) within the viewport. The inclination of the string is specified\n\
5699  in terms of differences of world coordinates making it easy to write\n\
5700  text parallel to a line in a graph.\n\
5701 \n\
5702  Redacted form: plptex(x, y, dx, dy, just, text)\n\
5703 \n\
5704  This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5705 \n\
5706 \n\
5707 \n\
5708 SYNOPSIS:\n\
5709 \n\
5710 plptex(x, y, dx, dy, just, text)\n\
5711 \n\
5712 ARGUMENTS:\n\
5713 \n\
5714  x (PLFLT, input) : x coordinate of reference point of string.\n\
5715 \n\
5716  y (PLFLT, input) : y coordinate of reference point of string.\n\
5717 \n\
5718  dx (PLFLT, input) : Together with dy, this specifies the\n\
5719  inclination of the string. The baseline of the string is parallel\n\
5720  to a line joining (\n\
5721  x,\n\
5722  y) to (\n\
5723  x+\n\
5724  dx,\n\
5725  y+\n\
5726  dy) .\n\
5727 \n\
5728  dy (PLFLT, input) : Together with dx, this specifies the\n\
5729  inclination of the string.\n\
5730 \n\
5731  just (PLFLT, input) : Specifies the position of the string relative\n\
5732  to its reference point. If just=0. , the reference point is at\n\
5733  the left and if just=1. , it is at the right of the string. Other\n\
5734  values of just give intermediate justifications.\n\
5735 \n\
5736  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5737  written out.\n\
5738 ";
5739 static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
5740 Set z axis parameters\n\
5741 \n\
5742 DESCRIPTION:\n\
5743 \n\
5744  Identical to plsxax, except that arguments are flags for z axis. See\n\
5745  the description of plsxax for more detail.\n\
5746 \n\
5747  Redacted form: plszax(digmax, digits)\n\
5748 \n\
5749  This function is used in example 31.\n\
5750 \n\
5751 \n\
5752 \n\
5753 SYNOPSIS:\n\
5754 \n\
5755 plszax(digmax, digits)\n\
5756 \n\
5757 ARGUMENTS:\n\
5758 \n\
5759  digmax (PLINT, input) : Variable to set the maximum number of\n\
5760  digits for the z axis. If nonzero, the printed label will be\n\
5761  switched to a floating-point representation when the number of\n\
5762  digits exceeds digmax.\n\
5763 \n\
5764  digits (PLINT, input) : Field digits value. Currently, changing\n\
5765  its value here has no effect since it is set only by plbox or\n\
5766  plbox3. However, the user may obtain its value after a call to\n\
5767  either of these functions by calling plgzax.\n\
5768 ";
5769 static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
5770 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5771 \n\
5772 DESCRIPTION:\n\
5773 \n\
5774  This variant of plsurf3d (see that function\'s documentation for more\n\
5775  details) should be suitable for the case where the area of the x, y\n\
5776  coordinate grid where z is defined can be non-rectangular. The limits\n\
5777  of that grid are provided by the parameters indexxmin, indexxmax,\n\
5778  indexymin, and indexymax.\n\
5779 \n\
5780  Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5781  indexymax)\n\
5782 \n\
5783  This function is used in example 8.\n\
5784 \n\
5785 \n\
5786 \n\
5787 SYNOPSIS:\n\
5788 \n\
5789 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5790 \n\
5791 ARGUMENTS:\n\
5792 \n\
5793  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5794  which the function is evaluated.\n\
5795 \n\
5796  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5797  which the function is evaluated.\n\
5798 \n\
5799  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5800  plot. Should have dimensions of\n\
5801  nx by\n\
5802  ny.\n\
5803 \n\
5804  nx (PLINT, input) : Number of x values at which function is\n\
5805  evaluated.\n\
5806 \n\
5807  ny (PLINT, input) : Number of y values at which function is\n\
5808  evaluated.\n\
5809 \n\
5810  opt (PLINT, input) : Determines the way in which the surface is\n\
5811  represented. To specify more than one option just add the options,\n\
5812  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5813  connecting points at which function is defined.\n\
5814  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5815  using parameters\n\
5816  nlevel and\n\
5817  clevel.\n\
5818  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5819  using parameters\n\
5820  nlevel and\n\
5821  clevel.\n\
5822  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5823  the borders of the plotted function.\n\
5824  opt=MAG_COLOR : the surface is colored according to the value\n\
5825  of Z; if MAG_COLOR is not used, then the surface is colored\n\
5826  according to the intensity of the reflected light in the\n\
5827  surface from a light source whose position is set using\n\
5828  pllightsource.\n\
5829 \n\
5830 \n\
5831  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5832  levels.\n\
5833 \n\
5834  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5835 \n\
5836  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5837  corresponds to the first x index where z is defined.\n\
5838 \n\
5839  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5840  which corresponds (by convention) to one more than the last x\n\
5841  index value where z is defined.\n\
5842 \n\
5843  indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5844  values which all must be ≥ 0. These values are the first y index\n\
5845  where z is defined for a particular x index in the range from\n\
5846  indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5847  indexxmax.\n\
5848 \n\
5849  indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5850  values which all must be ≤ ny. These values correspond (by\n\
5851  convention) to one more than the last y index where z is defined\n\
5852  for a particular x index in the range from indexxmin to indexxmax\n\
5853  - 1. The dimension of indexymax is indexxmax.\n\
5854 ";
5855 static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
5856 Set font\n\
5857 \n\
5858 DESCRIPTION:\n\
5859 \n\
5860  Sets the font used for subsequent text and symbols. For devices that\n\
5861  still use Hershey fonts this routine has no effect unless the Hershey\n\
5862  fonts with extended character set are loaded (see plfontld). For\n\
5863  unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5864  this routine calls the plsfci routine with argument set up\n\
5865  appropriately for the various cases below. However, this method of\n\
5866  specifying the font for unicode-aware devices is deprecated, and the\n\
5867  much more flexible method of calling plsfont directly is recommended\n\
5868  instead (where plsfont provides a user-friendly interface to plsfci),\n\
5869 \n\
5870  Redacted form: plfont(ifont)\n\
5871 \n\
5872  This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5873 \n\
5874 \n\
5875 \n\
5876 SYNOPSIS:\n\
5877 \n\
5878 plfont(ifont)\n\
5879 \n\
5880 ARGUMENTS:\n\
5881 \n\
5882  ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5883  (simplest and fastest)\n\
5884  2: Serif font\n\
5885  3: Italic font\n\
5886  4: Script font\n\
5887 ";
5888 static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
5889 Get the cmap1 argument range for continuous color plots\n\
5890 \n\
5891 DESCRIPTION:\n\
5892 \n\
5893  Get the cmap1 argument range for continuous color plots. (Use\n\
5894  plscmap1_range to set the cmap1 argument range.)\n\
5895 \n\
5896  Redacted form: plgcmap1_range(min_color, max_color)\n\
5897 \n\
5898  This function is currently not used in any example.\n\
5899 \n\
5900 \n\
5901 \n\
5902 SYNOPSIS:\n\
5903 \n\
5904 plgcmap1_range(min_color, max_color)\n\
5905 \n\
5906 ARGUMENTS:\n\
5907 \n\
5908  min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5909  minimum cmap1 argument.\n\
5910 \n\
5911  max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5912  maximum cmap1 argument.\n\
5913 ";
5914 static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
5915 Set the cmap1 argument range for continuous color plots\n\
5916 \n\
5917 DESCRIPTION:\n\
5918 \n\
5919  Set the cmap1 argument range for continuous color plots that\n\
5920  corresponds to the range of data values. The maximum range\n\
5921  corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5922  the cmap1 argument range that is specified with this routine, the\n\
5923  smaller the subset of the cmap1 color palette that is used to\n\
5924  represent the continuous data being plotted. If\n\
5925  min_color is greater than\n\
5926  max_color or\n\
5927  max_color is greater than 1.0 or\n\
5928  min_color is less than 0.0 then no change is made to the cmap1\n\
5929  argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5930 \n\
5931  Redacted form: plscmap1_range(min_color, max_color)\n\
5932 \n\
5933  This function is currently used in example 33.\n\
5934 \n\
5935 \n\
5936 \n\
5937 SYNOPSIS:\n\
5938 \n\
5939 plscmap1_range(min_color, max_color)\n\
5940 \n\
5941 ARGUMENTS:\n\
5942 \n\
5943  min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5944  than 0.0, then 0.0 is used instead.\n\
5945 \n\
5946  max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5947  than 1.0, then 1.0 is used instead.\n\
5948 ";
5949 static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
5950 Draw a circular or elliptical arc\n\
5951 \n\
5952 DESCRIPTION:\n\
5953 \n\
5954  Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5955  semiminor axis b, starting at angle1 and ending at angle2.\n\
5956 \n\
5957  Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5958  fill)\n\
5959 \n\
5960 \n\
5961  This function is used in examples 3 and 27.\n\
5962 \n\
5963 \n\
5964 \n\
5965 SYNOPSIS:\n\
5966 \n\
5967 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5968 \n\
5969 ARGUMENTS:\n\
5970 \n\
5971  x (PLFLT, input) : X coordinate of arc center.\n\
5972 \n\
5973  y (PLFLT, input) : Y coordinate of arc center.\n\
5974 \n\
5975  a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5976 \n\
5977  b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5978 \n\
5979  angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5980  semimajor axis.\n\
5981 \n\
5982  angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5983  semimajor axis.\n\
5984 \n\
5985  rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5986  X-axis.\n\
5987 \n\
5988  fill (PLBOOL, input) : Draw a filled arc.\n\
5989 ";
5990 static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5991 Plot 3-d surface plot\n\
5992 \n\
5993 DESCRIPTION:\n\
5994 \n\
5995  Plots a three-dimensional surface plot within the environment set up\n\
5996  by plw3d. The surface is defined by the matrix z[\n\
5997  nx][\n\
5998  ny] , the point z[i][j] being the value of the function at (\n\
5999  x[i],\n\
6000  y[j]). Note that the points in vectors x and y do not need to be\n\
6001  equally spaced, but must be stored in ascending order. The parameter\n\
6002  opt controls the way in which the surface is displayed. For further\n\
6003  details see the PLplot documentation. The only difference between\n\
6004  plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
6005  while plot3d only draws the surface as viewed from the top.\n\
6006 \n\
6007  Redacted form: plot3d(x, y, z, opt, side)\n\
6008 \n\
6009  This function is used in examples 11 and 21.\n\
6010 \n\
6011 \n\
6012 \n\
6013 SYNOPSIS:\n\
6014 \n\
6015 plot3d(x, y, z, nx, ny, opt, side)\n\
6016 \n\
6017 ARGUMENTS:\n\
6018 \n\
6019  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
6020  which the function is evaluated.\n\
6021 \n\
6022  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
6023  which the function is evaluated.\n\
6024 \n\
6025  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
6026  plot. Should have dimensions of\n\
6027  nx by\n\
6028  ny.\n\
6029 \n\
6030  nx (PLINT, input) : Number of x values at which function is\n\
6031  evaluated.\n\
6032 \n\
6033  ny (PLINT, input) : Number of y values at which function is\n\
6034  evaluated.\n\
6035 \n\
6036  opt (PLINT, input) : Determines the way in which the surface is\n\
6037  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
6038  function of x for each value of y[j] .\n\
6039  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
6040  for each value of x[i] .\n\
6041  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
6042  at which function is defined.\n\
6043 \n\
6044 \n\
6045  side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
6046  should be draw on the figure. If side is true sides are drawn,\n\
6047  otherwise no sides are drawn.\n\
6048 ";
6049 static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
6050 Set area line fill pattern\n\
6051 \n\
6052 DESCRIPTION:\n\
6053 \n\
6054  Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
6055  The pattern consists of 1 or 2 sets of parallel lines with specified\n\
6056  inclinations and spacings. The arguments to this routine are the\n\
6057  number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
6058  elements) specifying the inclinations in tenths of a degree and the\n\
6059  spacing in micrometers. (See also plpsty)\n\
6060 \n\
6061  Redacted form: General: plpat(inc, del)\n\
6062 \n\
6063 \n\
6064  This function is used in example 15.\n\
6065 \n\
6066 \n\
6067 \n\
6068 SYNOPSIS:\n\
6069 \n\
6070 plpat(nlin, inc, del)\n\
6071 \n\
6072 ARGUMENTS:\n\
6073 \n\
6074  nlin (PLINT, input) : Number of sets of lines making up the\n\
6075  pattern, either 1 or 2.\n\
6076 \n\
6077  inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
6078  inclination in tenths of a degree. (Should be between -900 and\n\
6079  900).\n\
6080 \n\
6081  del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
6082  spacing in micrometers between the lines making up the pattern.\n\
6083 ";
6084 static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
6085 Get x axis parameters\n\
6086 \n\
6087 DESCRIPTION:\n\
6088 \n\
6089  Returns current values of the p_digmax and p_digits flags for the x\n\
6090  axis. p_digits is updated after the plot is drawn, so this routine\n\
6091  should only be called after the call to plbox (or plbox3) is complete.\n\
6092  See the PLplot documentation for more information.\n\
6093 \n\
6094  Redacted form: plgxax(p_digmax, p_digits)\n\
6095 \n\
6096  This function is used in example 31.\n\
6097 \n\
6098 \n\
6099 \n\
6100 SYNOPSIS:\n\
6101 \n\
6102 plgxax(p_digmax, p_digits)\n\
6103 \n\
6104 ARGUMENTS:\n\
6105 \n\
6106  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
6107  number of digits for the x axis. If nonzero, the printed label\n\
6108  has been switched to a floating-point representation when the\n\
6109  number of digits exceeds this value.\n\
6110 \n\
6111  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6112  number of digits for the numeric labels (x axis) from the last\n\
6113  plot.\n\
6114 ";
6115 static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
6116 Draw filled polygon in 3D\n\
6117 \n\
6118 DESCRIPTION:\n\
6119 \n\
6120  Fills the 3D polygon defined by the n points in the x, y, and z\n\
6121  vectors using the pattern defined by plpsty or plpat. The routine\n\
6122  will automatically close the polygon between the last and first\n\
6123  vertices. If multiple closed polygons are passed in x, y, and z then\n\
6124  plfill3 will fill in between them.\n\
6125 \n\
6126  Redacted form: General: plfill3(x, y, z)\n\
6127 \n\
6128 \n\
6129  This function is used in example 15.\n\
6130 \n\
6131 \n\
6132 \n\
6133 SYNOPSIS:\n\
6134 \n\
6135 plfill3(n, x, y, z)\n\
6136 \n\
6137 ARGUMENTS:\n\
6138 \n\
6139  n (PLINT, input) : Number of vertices in polygon.\n\
6140 \n\
6141  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6142  vertices.\n\
6143 \n\
6144  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6145  vertices.\n\
6146 \n\
6147  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6148  vertices.\n\
6149 ";
6150 static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6151 Set color, cmap0\n\
6152 \n\
6153 DESCRIPTION:\n\
6154 \n\
6155  Sets the color index for cmap0 (see the PLplot documentation).\n\
6156 \n\
6157  Redacted form: plcol0(icol0)\n\
6158 \n\
6159  This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6160 \n\
6161 \n\
6162 \n\
6163 SYNOPSIS:\n\
6164 \n\
6165 plcol0(icol0)\n\
6166 \n\
6167 ARGUMENTS:\n\
6168 \n\
6169  icol0 (PLINT, input) : Integer representing the color. The\n\
6170  defaults at present are (these may change):\n\
6171  0 black (default background)\n\
6172  1 red (default foreground)\n\
6173  2 yellow\n\
6174  3 green\n\
6175  4 aquamarine\n\
6176  5 pink\n\
6177  6 wheat\n\
6178  7 grey\n\
6179  8 brown\n\
6180  9 blue\n\
6181  10 BlueViolet\n\
6182  11 cyan\n\
6183  12 turquoise\n\
6184  13 magenta\n\
6185  14 salmon\n\
6186  15 white\n\
6187 \n\
6188  Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6189  change an individual color in the cmap0 color palette.\n\
6190 ";
6191 static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
6192 Draw text at points defined by Shapefile data in world coordinates\n\
6193 \n\
6194 DESCRIPTION:\n\
6195 \n\
6196  As per plmapline, however the items are plotted as text in the same\n\
6197  way as plptex.\n\
6198 \n\
6199  Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
6200  miny, maxy, plotentry)\n\
6201 \n\
6202  This function is used in example 19.\n\
6203 \n\
6204 \n\
6205 \n\
6206 SYNOPSIS:\n\
6207 \n\
6208 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
6209 \n\
6210 ARGUMENTS:\n\
6211 \n\
6212  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6213  transform the coordinates given in the shapefile into a plot\n\
6214  coordinate system. By using this transform, we can change from a\n\
6215  longitude, latitude coordinate to a polar stereographic project,\n\
6216  for example. Initially, x[0]..[n-1] are the longitudes and\n\
6217  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6218  mapform(), x[] and y[] should be replaced by the corresponding\n\
6219  plot coordinates. If no transform is desired, mapform can be\n\
6220  replaced by NULL.\n\
6221 \n\
6222  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6223  the file name of a set of Shapefile files without the file\n\
6224  extension.\n\
6225 \n\
6226  dx (PLFLT, input) : Used to define the slope of the texts which is\n\
6227  dy/dx.\n\
6228 \n\
6229  dy (PLFLT, input) : Used to define the slope of the texts which is\n\
6230  dy/dx.\n\
6231 \n\
6232  just (PLFLT, input) : Set the justification of the text. The value\n\
6233  given will be the fraction of the distance along the string that\n\
6234  sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
6235  centralized text and 1.0 gives right aligned text.\n\
6236 \n\
6237  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
6238 \n\
6239  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6240  be in the same units as used by the Shapefile. You could use a\n\
6241  very large negative number to plot everything, but you can improve\n\
6242  performance by limiting the area drawn. The units must match those\n\
6243  of the Shapefile projection, which may be for example longitude or\n\
6244  distance. The value of minx must be less than the value of maxx.\n\
6245 \n\
6246  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6247  use a very large number to plot everything, but you can improve\n\
6248  performance by limiting the area drawn.\n\
6249 \n\
6250  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6251  be in the same units as used by the Shapefile. You could use a\n\
6252  very large negative number to plot everything, but you can improve\n\
6253  performance by limiting the area drawn. The units must match those\n\
6254  of the Shapefile projection, which may be for example latitude or\n\
6255  distance. The value of miny must be less than the value of maxy.\n\
6256 \n\
6257  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6258  use a very large number to plot everything, but you can improve\n\
6259  performance by limiting the area drawn.\n\
6260 \n\
6261  plotentry (PLINT, input) : An integer indicating which text string\n\
6262  of the Shapefile (zero indexed) will be drawn.\n\
6263 ";
6264 static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
6265 Draw a line between two points\n\
6266 \n\
6267 DESCRIPTION:\n\
6268 \n\
6269  Joins the point (\n\
6270  x1,\n\
6271  y1) to (\n\
6272  x2,\n\
6273  y2).\n\
6274 \n\
6275  Redacted form: pljoin(x1,y1,x2,y2)\n\
6276 \n\
6277  This function is used in examples 3 and 14.\n\
6278 \n\
6279 \n\
6280 \n\
6281 SYNOPSIS:\n\
6282 \n\
6283 pljoin(x1, y1, x2, y2)\n\
6284 \n\
6285 ARGUMENTS:\n\
6286 \n\
6287  x1 (PLFLT, input) : x coordinate of first point.\n\
6288 \n\
6289  y1 (PLFLT, input) : y coordinate of first point.\n\
6290 \n\
6291  x2 (PLFLT, input) : x coordinate of second point.\n\
6292 \n\
6293  y2 (PLFLT, input) : y coordinate of second point.\n\
6294 ";
6295 static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6296 Set color, cmap1\n\
6297 \n\
6298 DESCRIPTION:\n\
6299 \n\
6300  Sets the color for cmap1 (see the PLplot documentation).\n\
6301 \n\
6302  Redacted form: plcol1(col1)\n\
6303 \n\
6304  This function is used in examples 12 and 21.\n\
6305 \n\
6306 \n\
6307 \n\
6308 SYNOPSIS:\n\
6309 \n\
6310 plcol1(col1)\n\
6311 \n\
6312 ARGUMENTS:\n\
6313 \n\
6314  col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6315  is mapped to color using the continuous cmap1 palette which by\n\
6316  default ranges from blue to the background color to red. The\n\
6317  cmap1 palette can also be straightforwardly changed by the user\n\
6318  with plscmap1 or plscmap1l.\n\
6319 ";
6320 static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
6321 Set orientation\n\
6322 \n\
6323 DESCRIPTION:\n\
6324 \n\
6325  Set integer plot orientation parameter. This function is identical to\n\
6326  plsdiori except for the type of the argument, and should be used in\n\
6327  the same way. See the documentation of plsdiori for details.\n\
6328 \n\
6329  Redacted form: plsori(ori)\n\
6330 \n\
6331  This function is used in example 3.\n\
6332 \n\
6333 \n\
6334 \n\
6335 SYNOPSIS:\n\
6336 \n\
6337 plsori(ori)\n\
6338 \n\
6339 ARGUMENTS:\n\
6340 \n\
6341  ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
6342  portrait, etc.) The value is multiplied by 90 degrees to get the\n\
6343  angle.\n\
6344 ";
6345 static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6346 Calculate continuous time from broken-down time for the current stream\n\
6347 \n\
6348 DESCRIPTION:\n\
6349 \n\
6350  Calculate continuous time, ctime, from broken-down time for the\n\
6351  current stream. The broken-down\n\
6352  time is specified by the following parameters: year, month, day, hour,\n\
6353  min, and sec. This function is the inverse of plbtime.\n\
6354 \n\
6355  The PLplot definition of broken-down time is a calendar time that\n\
6356  completely ignores all time zone offsets, i.e., it is the user\'s\n\
6357  responsibility to apply those offsets (if so desired) before using the\n\
6358  PLplot time API. By default broken-down time is defined using the\n\
6359  proleptic Gregorian calendar without the insertion of leap seconds and\n\
6360  continuous time is defined as the number of seconds since the Unix\n\
6361  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6362  broken-down and continuous time are possible, see plconfigtime which\n\
6363  specifies that transformation for the current stream.\n\
6364 \n\
6365  Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6366  ctime)\n\
6367 \n\
6368 \n\
6369  This function is used in example 29.\n\
6370 \n\
6371 \n\
6372 \n\
6373 SYNOPSIS:\n\
6374 \n\
6375 plctime(year, month, day, hour, min, sec, ctime)\n\
6376 \n\
6377 ARGUMENTS:\n\
6378 \n\
6379  year (PLINT, input) : Input year.\n\
6380 \n\
6381  month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6382  (December).\n\
6383 \n\
6384  day (PLINT, input) : Input day in range from 1 to 31.\n\
6385 \n\
6386  hour (PLINT, input) : Input hour in range from 0 to 23\n\
6387 \n\
6388  min (PLINT, input) : Input minute in range from 0 to 59.\n\
6389 \n\
6390  sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6391 \n\
6392  ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6393  time calculated from the broken-down time specified by the\n\
6394  previous parameters.\n\
6395 ";
6396 static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
6397 Plot continental outline or shapefile data in world coordinates\n\
6398 \n\
6399 DESCRIPTION:\n\
6400 \n\
6401  Plots continental outlines or shapefile data in world coordinates. A\n\
6402  demonstration of how to use this function to create different\n\
6403  projections can be found in examples/c/x19c. PLplot is provided with\n\
6404  basic coastal outlines and USA state borders. To use the map\n\
6405  functionality PLplot must be compiled with the shapelib library.\n\
6406  Shapefiles have become a popular standard for geographical data and\n\
6407  data in this format can be easily found from a number of online\n\
6408  sources. Shapefile data is actually provided as three or more files\n\
6409  with the same filename, but different extensions. The .shp and .shx\n\
6410  files are required for plotting Shapefile data with PLplot.\n\
6411 \n\
6412  PLplot currently supports the point, multipoint, polyline and polygon\n\
6413  objects within shapefiles. However holes in polygons are not\n\
6414  supported. When plmap is used the type of object is derived from the\n\
6415  shapefile, if you wish to override the type then use one of the other\n\
6416  plmap variants. The built in maps have line data only.\n\
6417 \n\
6418  Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
6419 \n\
6420  This function is used in example 19.\n\
6421 \n\
6422 \n\
6423 \n\
6424 SYNOPSIS:\n\
6425 \n\
6426 plmap(mapform, name, minx, maxx, miny, maxy)\n\
6427 \n\
6428 ARGUMENTS:\n\
6429 \n\
6430  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6431  transform the original map data coordinates to a new coordinate\n\
6432  system. The PLplot-supplied map data is provided as latitudes and\n\
6433  longitudes; other Shapefile data may be provided in other\n\
6434  coordinate systems as can be found in their .prj plain text files.\n\
6435  For example, by using this transform we can change from a\n\
6436  longitude, latitude coordinate to a polar stereographic\n\
6437  projection. Initially, x[0]..[n-1] are the original x coordinates\n\
6438  (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
6439  corresponding y coordinates (latitudes for the PLplot supplied\n\
6440  data). After the call to mapform(), x[] and y[] should be\n\
6441  replaced by the corresponding plot coordinates. If no transform is\n\
6442  desired, mapform can be replaced by NULL.\n\
6443 \n\
6444  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6445  the type of map plotted. This is either one of the PLplot built-in\n\
6446  maps or the file name of a set of Shapefile files without the file\n\
6447  extensions. For the PLplot built-in maps the possible values are:\n\
6448  \"globe\" -- continental outlines\n\
6449  \"usa\" -- USA and state boundaries\n\
6450  \"cglobe\" -- continental outlines and countries\n\
6451  \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6452 \n\
6453 \n\
6454  minx (PLFLT, input) : The minimum x value of map elements to be\n\
6455  drawn. The units must match the shapefile (built in maps are\n\
6456  degrees lat/lon). Objects in the file which do not encroach on the\n\
6457  box defined by minx, maxx, miny, maxy will not be rendered. But\n\
6458  note this is simply an optimisation, not a clipping so for objects\n\
6459  with some points inside the box and some points outside the box\n\
6460  all the points will be rendered. These parameters also define\n\
6461  latitude and longitude wrapping for shapefiles using these units.\n\
6462  Longitude points will be wrapped by integer multiples of 360\n\
6463  degrees to place them in the box. This allows the same data to be\n\
6464  used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
6465  you plot from -180-540 you will get two cycles of data drawn. The\n\
6466  value of minx must be less than the value of maxx. Passing in a\n\
6467  nan, max/-max floating point number or +/-infinity will case the\n\
6468  bounding box from the shapefile to be used.\n\
6469 \n\
6470  maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6471  drawn - see minx.\n\
6472 \n\
6473  miny (PLFLT, input) : The minimum y value of map elements to be\n\
6474  drawn - see minx.\n\
6475 \n\
6476  maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6477  drawn - see minx.\n\
6478 ";
6479 static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
6480 Calculate broken-down time from continuous time for the current stream\n\
6481 \n\
6482 DESCRIPTION:\n\
6483 \n\
6484  Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6485  continuous time, ctime for the current stream. This function is the\n\
6486  inverse of plctime.\n\
6487 \n\
6488  The PLplot definition of broken-down time is a calendar time that\n\
6489  completely ignores all time zone offsets, i.e., it is the user\'s\n\
6490  responsibility to apply those offsets (if so desired) before using the\n\
6491  PLplot time API. By default broken-down time is defined using the\n\
6492  proleptic Gregorian calendar without the insertion of leap seconds and\n\
6493  continuous time is defined as the number of seconds since the Unix\n\
6494  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6495  broken-down and continuous time are possible, see plconfigtime.\n\
6496 \n\
6497  Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6498  ctime)\n\
6499 \n\
6500 \n\
6501  This function is used in example 29.\n\
6502 \n\
6503 \n\
6504 \n\
6505 SYNOPSIS:\n\
6506 \n\
6507 plbtime(year, month, day, hour, min, sec, ctime)\n\
6508 \n\
6509 ARGUMENTS:\n\
6510 \n\
6511  year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6512  positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6513  non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6514  BCE, etc.)\n\
6515 \n\
6516  month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6517  the year in the range from 0 (January) to 11 (December).\n\
6518 \n\
6519  day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6520  month in the range from 1 to 31.\n\
6521 \n\
6522  hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6523  day in the range from 0 to 23.\n\
6524 \n\
6525  min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6526  hour in the range from 0 to 59\n\
6527 \n\
6528  sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6529  minute in range from 0. to 60.\n\
6530 \n\
6531  ctime (PLFLT, input) : Continuous time from which the broken-down\n\
6532  time is calculated.\n\
6533 ";
6534 static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
6535 Get current stream number\n\
6536 \n\
6537 DESCRIPTION:\n\
6538 \n\
6539  Gets the number of the current output stream. See also plsstrm.\n\
6540 \n\
6541  Redacted form: plgstrm(p_strm)\n\
6542 \n\
6543  This function is used in example 1,20.\n\
6544 \n\
6545 \n\
6546 \n\
6547 SYNOPSIS:\n\
6548 \n\
6549 plgstrm(p_strm)\n\
6550 \n\
6551 ARGUMENTS:\n\
6552 \n\
6553  p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6554  stream value.\n\
6555 ";
6556 static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
6557 Draw a line in 3 space\n\
6558 \n\
6559 DESCRIPTION:\n\
6560 \n\
6561  Draws line in 3 space defined by n points in x, y, and z. You must\n\
6562  first set up the viewport, the 2d viewing window (in world\n\
6563  coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6564  more info.\n\
6565 \n\
6566  Redacted form: plline3(x, y, z)\n\
6567 \n\
6568  This function is used in example 18.\n\
6569 \n\
6570 \n\
6571 \n\
6572 SYNOPSIS:\n\
6573 \n\
6574 plline3(n, x, y, z)\n\
6575 \n\
6576 ARGUMENTS:\n\
6577 \n\
6578  n (PLINT, input) : Number of points defining line.\n\
6579 \n\
6580  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6581  points.\n\
6582 \n\
6583  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6584  points.\n\
6585 \n\
6586  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6587  points.\n\
6588 ";
6589 static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
6590 Load Hershey fonts\n\
6591 \n\
6592 DESCRIPTION:\n\
6593 \n\
6594  Loads the Hershey fonts used for text and symbols. This routine may\n\
6595  be called before or after initializing PLplot. If not explicitly\n\
6596  called before PLplot initialization, then by default that\n\
6597  initialization loads Hershey fonts with the extended character set.\n\
6598  This routine only has a practical effect for devices that still use\n\
6599  Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6600  system fonts instead of Hershey fonts).\n\
6601 \n\
6602  Redacted form: plfontld(fnt)\n\
6603 \n\
6604  This function is used in examples 1 and 7.\n\
6605 \n\
6606 \n\
6607 \n\
6608 SYNOPSIS:\n\
6609 \n\
6610 plfontld(fnt)\n\
6611 \n\
6612 ARGUMENTS:\n\
6613 \n\
6614  fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6615  A zero value specifies Hershey fonts with the standard character\n\
6616  set and a non-zero value (the default assumed if plfontld is never\n\
6617  called) specifies Hershey fonts with the extended character set.\n\
6618 ";
6619 static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
6620 Set any command-line option\n\
6621 \n\
6622 DESCRIPTION:\n\
6623 \n\
6624  Set any command-line option internally from a program before it\n\
6625  invokes plinit. opt is the name of the command-line option and optarg\n\
6626  is the corresponding command-line option argument.\n\
6627 \n\
6628  This function returns 0 on success.\n\
6629 \n\
6630  Redacted form: plsetopt(opt, optarg)\n\
6631 \n\
6632  This function is used in example 14.\n\
6633 \n\
6634 \n\
6635 \n\
6636 SYNOPSIS:\n\
6637 \n\
6638 PLINT plsetopt(opt, optarg)\n\
6639 \n\
6640 ARGUMENTS:\n\
6641 \n\
6642  opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6643  the command-line option.\n\
6644 \n\
6645  optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6646  containing the argument of the command-line option.\n\
6647 ";
6648 static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
6649 Plot all or a subset of Shapefile data using lines in world coordinates\n\
6650 \n\
6651 DESCRIPTION:\n\
6652 \n\
6653  Plot all or a subset of Shapefile data using lines in world\n\
6654  coordinates. Our 19th standard example demonstrates how to use this\n\
6655  function. This function plots data from a Shapefile using lines as in\n\
6656  plmap, however it also has the option of also only drawing specified\n\
6657  elements from the Shapefile. The vector of indices of the required\n\
6658  elements are passed as a function argument. The Shapefile data should\n\
6659  include a metadata file (extension.dbf) listing all items within the\n\
6660  Shapefile. This file can be opened by most popular spreadsheet\n\
6661  programs and can be used to decide which indices to pass to this\n\
6662  function.\n\
6663 \n\
6664  Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6665  plotentries)\n\
6666 \n\
6667  This function is used in example 19.\n\
6668 \n\
6669 \n\
6670 \n\
6671 SYNOPSIS:\n\
6672 \n\
6673 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6674 \n\
6675 ARGUMENTS:\n\
6676 \n\
6677  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6678  transform the coordinates given in the shapefile into a plot\n\
6679  coordinate system. By using this transform, we can change from a\n\
6680  longitude, latitude coordinate to a polar stereographic project,\n\
6681  for example. Initially, x[0]..[n-1] are the longitudes and\n\
6682  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6683  mapform(), x[] and y[] should be replaced by the corresponding\n\
6684  plot coordinates. If no transform is desired, mapform can be\n\
6685  replaced by NULL.\n\
6686 \n\
6687  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6688  the file name of a set of Shapefile files without the file\n\
6689  extension.\n\
6690 \n\
6691  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6692  be in the same units as used by the Shapefile. You could use a\n\
6693  very large negative number to plot everything, but you can improve\n\
6694  performance by limiting the area drawn. The units must match those\n\
6695  of the Shapefile projection, which may be for example longitude or\n\
6696  distance. The value of minx must be less than the value of maxx.\n\
6697 \n\
6698  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6699  use a very large number to plot everything, but you can improve\n\
6700  performance by limiting the area drawn.\n\
6701 \n\
6702  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6703  be in the same units as used by the Shapefile. You could use a\n\
6704  very large negative number to plot everything, but you can improve\n\
6705  performance by limiting the area drawn. The units must match those\n\
6706  of the Shapefile projection, which may be for example latitude or\n\
6707  distance. The value of miny must be less than the value of maxy.\n\
6708 \n\
6709  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6710  use a very large number to plot everything, but you can improve\n\
6711  performance by limiting the area drawn.\n\
6712 \n\
6713  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6714  zero-based indices of the Shapefile elements which will be drawn.\n\
6715  Setting\n\
6716  plotentries to NULL will plot all elements of the Shapefile.\n\
6717 \n\
6718  nplotentries (PLINT, input) : The number of items in\n\
6719  plotentries. Ignored if\n\
6720  plotentries is NULL.\n\
6721 ";
6722 static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6723 Used to globally turn color output on/off\n\
6724 \n\
6725 DESCRIPTION:\n\
6726 \n\
6727  Used to globally turn color output on/off for those drivers/devices\n\
6728  that support it.\n\
6729 \n\
6730  Redacted form: plscolor(color)\n\
6731 \n\
6732  This function is used in example 31.\n\
6733 \n\
6734 \n\
6735 \n\
6736 SYNOPSIS:\n\
6737 \n\
6738 plscolor(color)\n\
6739 \n\
6740 ARGUMENTS:\n\
6741 \n\
6742  color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6743  turned off. If non-zero, color is turned on.\n\
6744 ";
6745 static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
6746 Wait for graphics input event and translate to world coordinates.\n\
6747 \n\
6748 DESCRIPTION:\n\
6749 \n\
6750  Wait for graphics input event and translate to world coordinates.\n\
6751  Returns 0 if no translation to world coordinates is possible.\n\
6752 \n\
6753  This function returns 1 on success and 0 if no translation to world\n\
6754  coordinates is possible.\n\
6755 \n\
6756  Redacted form: plGetCursor(gin)\n\
6757 \n\
6758  This function is used in examples 1 and 20.\n\
6759 \n\
6760 \n\
6761 \n\
6762 SYNOPSIS:\n\
6763 \n\
6764 PLINT plGetCursor(gin)\n\
6765 \n\
6766 ARGUMENTS:\n\
6767 \n\
6768  gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6769  which will contain the output. The structure is not allocated by\n\
6770  the routine and must exist before the function is called.\n\
6771 ";
6772 static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
6773 Get the current device (keyword) name\n\
6774 \n\
6775 DESCRIPTION:\n\
6776 \n\
6777  Get the current device (keyword) name. Note: you must have allocated\n\
6778  space for this (80 characters is safe).\n\
6779 \n\
6780  Redacted form: plgdev(p_dev)\n\
6781 \n\
6782  This function is used in example 14.\n\
6783 \n\
6784 \n\
6785 \n\
6786 SYNOPSIS:\n\
6787 \n\
6788 plgdev(p_dev)\n\
6789 \n\
6790 ARGUMENTS:\n\
6791 \n\
6792  p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6793  (with preallocated length of 80 characters or more) containing the\n\
6794  device (keyword) name.\n\
6795 ";
6796 static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
6797 Add a point to a strip chart\n\
6798 \n\
6799 DESCRIPTION:\n\
6800 \n\
6801  Add a point to a given pen of a given strip chart. There is no need\n\
6802  for all pens to have the same number of points or to be equally\n\
6803  sampled in the x coordinate. Allocates memory and rescales as\n\
6804  necessary.\n\
6805 \n\
6806  Redacted form: plstripa(id, pen, x, y)\n\
6807 \n\
6808  This function is used in example 17.\n\
6809 \n\
6810 \n\
6811 \n\
6812 SYNOPSIS:\n\
6813 \n\
6814 plstripa(id, pen, x, y)\n\
6815 \n\
6816 ARGUMENTS:\n\
6817 \n\
6818  id (PLINT, input) : Identification number of the strip chart (set\n\
6819  up in plstripc).\n\
6820 \n\
6821  pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6822 \n\
6823  x (PLFLT, input) : X coordinate of point to plot.\n\
6824 \n\
6825  y (PLFLT, input) : Y coordinate of point to plot.\n\
6826 ";
6827 static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
6828 Create a 4-pen strip chart\n\
6829 \n\
6830 DESCRIPTION:\n\
6831 \n\
6832  Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6833 \n\
6834  Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6835  ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6836  styline, legline, labx, laby, labz)\n\
6837 \n\
6838 \n\
6839  This function is used in example 17.\n\
6840 \n\
6841 \n\
6842 \n\
6843 SYNOPSIS:\n\
6844 \n\
6845 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6846 \n\
6847 ARGUMENTS:\n\
6848 \n\
6849  id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6850  number of the strip chart to use on plstripa and plstripd.\n\
6851 \n\
6852  xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6853  the x-axis specification as in plbox.\n\
6854 \n\
6855  yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6856  the y-axis specification as in plbox.\n\
6857 \n\
6858  xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6859  change as data are added.\n\
6860 \n\
6861  xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6862  change as data are added.\n\
6863 \n\
6864  xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6865  is multiplied by the factor (1 +\n\
6866  xjump) .\n\
6867 \n\
6868  ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6869  change as data are added.\n\
6870 \n\
6871  ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6872  change as data are added.\n\
6873 \n\
6874  xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6875 \n\
6876  ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6877 \n\
6878  y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6879  true, otherwise not.\n\
6880 \n\
6881  acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6882  otherwise slide display.\n\
6883 \n\
6884  colbox (PLINT, input) : Plot box color index (cmap0).\n\
6885 \n\
6886  collab (PLINT, input) : Legend color index (cmap0).\n\
6887 \n\
6888  colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6889  indices for the 4 pens.\n\
6890 \n\
6891  styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6892  indices for the 4 pens.\n\
6893 \n\
6894  legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6895  strings containing legends for the 4 pens.\n\
6896 \n\
6897  labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6898  the label for the x axis.\n\
6899 \n\
6900  laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6901  the label for the y axis.\n\
6902 \n\
6903  labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6904  the plot title.\n\
6905 ";
6906 static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
6907 Deletes and releases memory used by a strip chart\n\
6908 \n\
6909 DESCRIPTION:\n\
6910 \n\
6911  Deletes and releases memory used by a strip chart.\n\
6912 \n\
6913  Redacted form: plstripd(id)\n\
6914 \n\
6915  This function is used in example 17.\n\
6916 \n\
6917 \n\
6918 \n\
6919 SYNOPSIS:\n\
6920 \n\
6921 plstripd(id)\n\
6922 \n\
6923 ARGUMENTS:\n\
6924 \n\
6925  id (PLINT, input) : Identification number of strip chart to delete.\n\
6926 ";
6927 static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
6928 Specify viewport using coordinates and aspect ratio\n\
6929 \n\
6930 DESCRIPTION:\n\
6931 \n\
6932  Device-independent routine for setting up the viewport. The viewport\n\
6933  is chosen to be the largest with the given aspect ratio that fits\n\
6934  within the specified region (in terms of normalized subpage\n\
6935  coordinates). This routine is functionally equivalent to plvpor when\n\
6936  a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6937  routine reserves no extra space at the edges for labels.\n\
6938 \n\
6939  Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6940 \n\
6941  This function is used in example 9.\n\
6942 \n\
6943 \n\
6944 \n\
6945 SYNOPSIS:\n\
6946 \n\
6947 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6948 \n\
6949 ARGUMENTS:\n\
6950 \n\
6951  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6952  left-hand edge of the viewport.\n\
6953 \n\
6954  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6955  right-hand edge of the viewport.\n\
6956 \n\
6957  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6958  bottom edge of the viewport.\n\
6959 \n\
6960  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6961  edge of the viewport.\n\
6962 \n\
6963  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6964  axis.\n\
6965 ";
6966 static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
6967 Assign a function to use for generating custom axis labels\n\
6968 \n\
6969 DESCRIPTION:\n\
6970 \n\
6971  This function allows a user to provide their own function to provide\n\
6972  axis label text. The user function is given the numeric value for a\n\
6973  point on an axis and returns a string label to correspond with that\n\
6974  value. Custom axis labels can be enabled by passing appropriate\n\
6975  arguments to plenv, plbox, plbox3 and similar functions.\n\
6976 \n\
6977  This function is used in example 19.\n\
6978 \n\
6979 \n\
6980 \n\
6981 SYNOPSIS:\n\
6982 \n\
6983 plslabelfunc(label_func, label_data)\n\
6984 \n\
6985 ARGUMENTS:\n\
6986 \n\
6987  label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6988  label function. In order to reset to the default labelling, set\n\
6989  this to NULL. The labelling function parameters are, in order:\n\
6990  axis: This indicates which axis a label is being requested for.\n\
6991  The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6992 \n\
6993  value: This is the value along the axis which is being labelled.\n\
6994 \n\
6995  label_text: The string representation of the label value.\n\
6996 \n\
6997  length: The maximum length in characters allowed for label_text.\n\
6998 \n\
6999 \n\
7000  label_data (PLPointer, input) : This parameter may be used to pass\n\
7001  data to the label_func function.\n\
7002 ";
7003 static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
7004 Set length of major ticks\n\
7005 \n\
7006 DESCRIPTION:\n\
7007 \n\
7008  This sets up the length of the major ticks. The actual length is the\n\
7009  product of the default length and a scaling factor as for character\n\
7010  height.\n\
7011 \n\
7012  Redacted form: plsmaj(def, scale)\n\
7013 \n\
7014  This function is used in example 29.\n\
7015 \n\
7016 \n\
7017 \n\
7018 SYNOPSIS:\n\
7019 \n\
7020 plsmaj(def, scale)\n\
7021 \n\
7022 ARGUMENTS:\n\
7023 \n\
7024  def (PLFLT, input) : The default length of a major tick in\n\
7025  millimeters, should be set to zero if the default length is to\n\
7026  remain unchanged.\n\
7027 \n\
7028  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
7029  actual tick length.\n\
7030 ";
7031 static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
7032 Get the current library version number\n\
7033 \n\
7034 DESCRIPTION:\n\
7035 \n\
7036  Get the current library version number. Note: you must have allocated\n\
7037  space for this (80 characters is safe).\n\
7038 \n\
7039  Redacted form: plgver(p_ver)\n\
7040 \n\
7041  This function is used in example 1.\n\
7042 \n\
7043 \n\
7044 \n\
7045 SYNOPSIS:\n\
7046 \n\
7047 plgver(p_ver)\n\
7048 \n\
7049 ARGUMENTS:\n\
7050 \n\
7051  p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
7052  (with preallocated length of 80 characters or more) containing the\n\
7053  PLplot version number.\n\
7054 ";
7055 static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
7056 Set format of numerical label for contours\n\
7057 \n\
7058 DESCRIPTION:\n\
7059 \n\
7060  Set format of numerical label for contours.\n\
7061 \n\
7062  Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
7063 \n\
7064  This function is used example 9.\n\
7065 \n\
7066 \n\
7067 \n\
7068 SYNOPSIS:\n\
7069 \n\
7070 pl_setcontlabelformat(lexp, sigdig)\n\
7071 \n\
7072 ARGUMENTS:\n\
7073 \n\
7074  lexp (PLINT, input) : If the contour numerical label is greater\n\
7075  than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
7076  format is used. Default value of lexp is 4.\n\
7077 \n\
7078  sigdig (PLINT, input) : Number of significant digits. Default\n\
7079  value is 2.\n\
7080 ";
7081 static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
7082 Parse command-line arguments\n\
7083 \n\
7084 DESCRIPTION:\n\
7085 \n\
7086  Parse command-line arguments.\n\
7087 \n\
7088  plparseopts removes all recognized flags (decreasing argc\n\
7089  accordingly), so that invalid input may be readily detected. It can\n\
7090  also be used to process user command line flags. The user can merge\n\
7091  an option table of type PLOptionTable into the internal option table\n\
7092  info structure using plMergeOpts. Or, the user can specify that ONLY\n\
7093  the external table(s) be parsed by calling plClearOpts before\n\
7094  plMergeOpts.\n\
7095 \n\
7096  The default action taken by plparseopts is as follows:\n\
7097  Returns with an error if an unrecognized option or badly formed\n\
7098  option-value pair are encountered.\n\
7099  Returns immediately (return code 0) when the first non-option command\n\
7100  line argument is found.\n\
7101  Returns with the return code of the option handler, if one was called.\n\
7102 \n\
7103  Deletes command line arguments from argv list as they are found, and\n\
7104  decrements argc accordingly.\n\
7105  Does not show \"invisible\" options in usage or help messages.\n\
7106  Assumes the program name is contained in argv[0].\n\
7107 \n\
7108  These behaviors may be controlled through the\n\
7109  mode argument.\n\
7110 \n\
7111  Redacted form: General: plparseopts(argv, mode)\n\
7112 \n\
7113 \n\
7114  This function is used in all of the examples.\n\
7115 \n\
7116 \n\
7117 \n\
7118 SYNOPSIS:\n\
7119 \n\
7120 PLINT plparseopts(p_argc, argv, mode)\n\
7121 \n\
7122 ARGUMENTS:\n\
7123 \n\
7124  p_argc (int *, input/output) : Number of arguments.\n\
7125 \n\
7126  argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7127  strings containing *p_argc command-line arguments.\n\
7128 \n\
7129  mode (PLINT, input) : Parsing mode with the following\n\
7130  possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7131  and all error messages enabled, including program exit when an\n\
7132  error occurs. Anything on the command line that isn\'t recognized\n\
7133  as a valid option or option argument is flagged as an error.\n\
7134  PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7135  of errors.\n\
7136  PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7137  arguments.\n\
7138  PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7139  PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7140  pointer to the program name.\n\
7141  PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7142  PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7143  unrecognized arguments.\n\
7144 ";
7145 static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
7146 Initialization\n\
7147 \n\
7148 DESCRIPTION:\n\
7149 \n\
7150  Initializing the plotting package. The program prompts for the device\n\
7151  keyword or number of the desired output device. Hitting a RETURN in\n\
7152  response to the prompt is the same as selecting the first device. If\n\
7153  only one device is enabled when PLplot is installed, plstar will issue\n\
7154  no prompt. The output device is divided into nx by ny subpages, each\n\
7155  of which may be used independently. The subroutine pladv is used to\n\
7156  advance from one subpage to the next.\n\
7157 \n\
7158  Redacted form: plstar(nx, ny)\n\
7159 \n\
7160  This function is used in example 1.\n\
7161 \n\
7162 \n\
7163 \n\
7164 SYNOPSIS:\n\
7165 \n\
7166 plstar(nx, ny)\n\
7167 \n\
7168 ARGUMENTS:\n\
7169 \n\
7170  nx (PLINT, input) : Number of subpages to divide output page in the\n\
7171  x direction.\n\
7172 \n\
7173  ny (PLINT, input) : Number of subpages to divide output page in the\n\
7174  y direction.\n\
7175 ";
7176 static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
7177 Get FCI (font characterization integer)\n\
7178 \n\
7179 DESCRIPTION:\n\
7180 \n\
7181  Gets information about the current font using the FCI approach. See\n\
7182  the PLplot documentation for more information.\n\
7183 \n\
7184  Redacted form: plgfci(p_fci)\n\
7185 \n\
7186  This function is used in example 23.\n\
7187 \n\
7188 \n\
7189 \n\
7190 SYNOPSIS:\n\
7191 \n\
7192 plgfci(p_fci)\n\
7193 \n\
7194 ARGUMENTS:\n\
7195 \n\
7196  p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
7197  FCI value.\n\
7198 ";
7199 static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
7200 Set family file parameters\n\
7201 \n\
7202 DESCRIPTION:\n\
7203 \n\
7204  Sets variables dealing with output file familying. Does nothing if\n\
7205  familying not supported by the driver. This routine, if used, must be\n\
7206  called before initializing PLplot. See the PLplot documentation for\n\
7207  more information.\n\
7208 \n\
7209  Redacted form: plsfam(fam, num, bmax)\n\
7210 \n\
7211  This function is used in examples 14 and 31.\n\
7212 \n\
7213 \n\
7214 \n\
7215 SYNOPSIS:\n\
7216 \n\
7217 plsfam(fam, num, bmax)\n\
7218 \n\
7219 ARGUMENTS:\n\
7220 \n\
7221  fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
7222  is enabled.\n\
7223 \n\
7224  num (PLINT, input) : Current family file number.\n\
7225 \n\
7226  bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
7227  file.\n\
7228 ";
7229 static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
7230 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
7231 \n\
7232 DESCRIPTION:\n\
7233 \n\
7234  This is a variant of plscmap1l that supports alpha channel\n\
7235  transparency. It sets cmap1 colors using a piece-wise linear\n\
7236  relationship between cmap1 intensity index (0.0-1.0) and position in\n\
7237  HLS or RGB color space (see the PLplot documentation) with alpha\n\
7238  transparency value (0.0-1.0). It may be called at any time.\n\
7239 \n\
7240  Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
7241  alpha, alt_hue_path)\n\
7242 \n\
7243  This function is used in example 30.\n\
7244 \n\
7245 \n\
7246 \n\
7247 SYNOPSIS:\n\
7248 \n\
7249 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
7250 \n\
7251 ARGUMENTS:\n\
7252 \n\
7253  itype (PLBOOL, input) : true: RGB, false: HLS.\n\
7254 \n\
7255  npts (PLINT, input) : number of control points.\n\
7256 \n\
7257  intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
7258  intensity index (0.0-1.0) in ascending order for each control\n\
7259  point.\n\
7260 \n\
7261  coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
7262  coordinate (H or R) for each control point.\n\
7263 \n\
7264  coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
7265  coordinate (L or G) for each control point.\n\
7266 \n\
7267  coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
7268  coordinate (S or B) for each control point.\n\
7269 \n\
7270  alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
7271  transparency value (0.0-1.0) for each control point.\n\
7272 \n\
7273  alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
7274  npts - 1 elements) containing the alternative interpolation method\n\
7275  Boolean value for each control point interval. (alt_hue_path[i]\n\
7276  refers to the interpolation interval between the i and i + 1\n\
7277  control points).\n\
7278 ";
7279 static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
7280 Set page parameters\n\
7281 \n\
7282 DESCRIPTION:\n\
7283 \n\
7284  Sets the page configuration (optional). If an individual parameter is\n\
7285  zero then that parameter value is not updated. Not all parameters are\n\
7286  recognized by all drivers and the interpretation is device-dependent.\n\
7287  The X-window driver uses the length and offset parameters to determine\n\
7288  the window size and location. The length and offset values are\n\
7289  expressed in units that are specific to the current driver. For\n\
7290  instance: screen drivers will usually interpret them as number of\n\
7291  pixels, whereas printer drivers will usually use mm.\n\
7292 \n\
7293  This routine, if used, must be called before initializing PLplot. It\n\
7294  may be called at later times for interactive drivers to change only\n\
7295  the dpi for subsequent redraws which you can force via a call to\n\
7296  plreplot. If this function is not called then the page size defaults\n\
7297  to landscape A4 for drivers which use real world page sizes and 744\n\
7298  pixels wide by 538 pixels high for raster drivers. The default value\n\
7299  for dx and dy is 90 pixels per inch for raster drivers.\n\
7300 \n\
7301 \n\
7302 \n\
7303  Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7304 \n\
7305  This function is used in examples 14 and 31.\n\
7306 \n\
7307 \n\
7308 \n\
7309 SYNOPSIS:\n\
7310 \n\
7311 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7312 \n\
7313 ARGUMENTS:\n\
7314 \n\
7315  xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
7316  by raster drivers, ignored by drivers which use \"real world\" units\n\
7317  (e.g. mm).\n\
7318 \n\
7319  yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
7320  by raster drivers, ignored by drivers which use \"real world\" units\n\
7321  (e.g. mm).\n\
7322 \n\
7323  xleng (PLINT, input) : Page length, x.\n\
7324 \n\
7325  yleng (PLINT, input) : Page length, y.\n\
7326 \n\
7327  xoff (PLINT, input) : Page offset, x.\n\
7328 \n\
7329  yoff (PLINT, input) : Page offset, y.\n\
7330 ";
7331 static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7332 Set precision in numeric labels\n\
7333 \n\
7334 DESCRIPTION:\n\
7335 \n\
7336  Sets the number of places after the decimal point in numeric labels.\n\
7337 \n\
7338  Redacted form: plprec(setp, prec)\n\
7339 \n\
7340  This function is used in example 29.\n\
7341 \n\
7342 \n\
7343 \n\
7344 SYNOPSIS:\n\
7345 \n\
7346 plprec(setp, prec)\n\
7347 \n\
7348 ARGUMENTS:\n\
7349 \n\
7350  setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7351  automatically determines the number of places to use after the\n\
7352  decimal point in numeric labels (like those used to label axes).\n\
7353  If setp is 1 then prec sets the number of places.\n\
7354 \n\
7355  prec (PLINT, input) : The number of characters to draw after the\n\
7356  decimal point in numeric labels.\n\
7357 ";
7358 static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
7359 Copy state parameters from the reference stream to the current stream\n\
7360 \n\
7361 DESCRIPTION:\n\
7362 \n\
7363  Copies state parameters from the reference stream to the current\n\
7364  stream. Tell driver interface to map device coordinates unless flags\n\
7365  == 1.\n\
7366 \n\
7367  This function is used for making save files of selected plots (e.g.\n\
7368  from the TK driver). After initializing, you can get a copy of the\n\
7369  current plot to the specified device by switching to this stream and\n\
7370  issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
7371  appropriate. The plot buffer must have previously been enabled (done\n\
7372  automatically by some display drivers, such as X).\n\
7373 \n\
7374  Redacted form: plcpstrm(iplsr, flags)\n\
7375 \n\
7376  This function is used in example 1,20.\n\
7377 \n\
7378 \n\
7379 \n\
7380 SYNOPSIS:\n\
7381 \n\
7382 plcpstrm(iplsr, flags)\n\
7383 \n\
7384 ARGUMENTS:\n\
7385 \n\
7386  iplsr (PLINT, input) : Number of reference stream.\n\
7387 \n\
7388  flags (PLBOOL, input) : If flags is set to true the device\n\
7389  coordinates are not copied from the reference to current stream.\n\
7390 ";
7391 static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
7392 Plot a glyph at the specified points\n\
7393 \n\
7394 DESCRIPTION:\n\
7395 \n\
7396  Plot a glyph at the specified points. (This function is largely\n\
7397  superseded by plstring which gives access to many[!] more glyphs.)\n\
7398  code=-1 means try to just draw a point. Right now it\'s just a move\n\
7399  and a draw at the same place. Not ideal, since a sufficiently\n\
7400  intelligent output device may optimize it away, or there may be faster\n\
7401  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7402  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7403  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7404  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7405  code <= 127 the corresponding printable ASCII character is plotted.\n\
7406 \n\
7407  Redacted form: plpoin(x, y, code)\n\
7408 \n\
7409  This function is used in examples 1, 6, 14, and 29.\n\
7410 \n\
7411 \n\
7412 \n\
7413 SYNOPSIS:\n\
7414 \n\
7415 plpoin(n, x, y, code)\n\
7416 \n\
7417 ARGUMENTS:\n\
7418 \n\
7419  n (PLINT, input) : Number of points in the x and y vectors.\n\
7420 \n\
7421  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7422  points.\n\
7423 \n\
7424  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7425  points.\n\
7426 \n\
7427  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7428  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7429  each of the n points.\n\
7430 ";
7431 static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
7432 Enter or leave xor mode\n\
7433 \n\
7434 DESCRIPTION:\n\
7435 \n\
7436  Enter (when mode is true) or leave (when mode is false) xor mode for\n\
7437  those drivers (e.g., the xwin driver) that support it. Enables\n\
7438  erasing plots by drawing twice the same line, symbol, etc. If driver\n\
7439  is not capable of xor operation it returns a status of false.\n\
7440 \n\
7441  Redacted form: plxormod(mode, status)\n\
7442 \n\
7443  This function is used in examples 1 and 20.\n\
7444 \n\
7445 \n\
7446 \n\
7447 SYNOPSIS:\n\
7448 \n\
7449 plxormod(mode, status)\n\
7450 \n\
7451 ARGUMENTS:\n\
7452 \n\
7453  mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7454  is false means leave xor mode.\n\
7455 \n\
7456  status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7457  modestatus of true (false) means driver is capable (incapable) of\n\
7458  xor mode.\n\
7459 ";
7460 static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
7461 Get viewport limits in normalized device coordinates\n\
7462 \n\
7463 DESCRIPTION:\n\
7464 \n\
7465  Get viewport limits in normalized device coordinates.\n\
7466 \n\
7467  Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7468 \n\
7469 \n\
7470  This function is used in example 31.\n\
7471 \n\
7472 \n\
7473 \n\
7474 SYNOPSIS:\n\
7475 \n\
7476 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7477 \n\
7478 ARGUMENTS:\n\
7479 \n\
7480  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7481  viewport limit of the normalized device coordinate in x.\n\
7482 \n\
7483  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7484  viewport limit of the normalized device coordinate in x.\n\
7485 \n\
7486  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7487  viewport limit of the normalized device coordinate in y.\n\
7488 \n\
7489  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7490  viewport limit of the normalized device coordinate in y.\n\
7491 ";
7492 static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
7493 Plot surface mesh\n\
7494 \n\
7495 DESCRIPTION:\n\
7496 \n\
7497  Plots a surface mesh within the environment set up by plw3d. The\n\
7498  surface is defined by the matrix z[\n\
7499  nx][\n\
7500  ny] , the point z[i][j] being the value of the function at (\n\
7501  x[i],\n\
7502  y[j]). Note that the points in vectors x and y do not need to be\n\
7503  equally spaced, but must be stored in ascending order. The parameter\n\
7504  opt controls the way in which the surface is displayed. For further\n\
7505  details see the PLplot documentation.\n\
7506 \n\
7507  Redacted form: plmesh(x, y, z, opt)\n\
7508 \n\
7509  This function is used in example 11.\n\
7510 \n\
7511 \n\
7512 \n\
7513 SYNOPSIS:\n\
7514 \n\
7515 plmesh(x, y, z, nx, ny, opt)\n\
7516 \n\
7517 ARGUMENTS:\n\
7518 \n\
7519  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7520  which the function is evaluated.\n\
7521 \n\
7522  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7523  which the function is evaluated.\n\
7524 \n\
7525  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7526  plot. Should have dimensions of\n\
7527  nx by\n\
7528  ny.\n\
7529 \n\
7530  nx (PLINT, input) : Number of x values at which function has been\n\
7531  evaluated.\n\
7532 \n\
7533  ny (PLINT, input) : Number of y values at which function has been\n\
7534  evaluated.\n\
7535 \n\
7536  opt (PLINT, input) : Determines the way in which the surface is\n\
7537  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7538  function of x for each value of y[j] .\n\
7539  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7540  for each value of x[i] .\n\
7541  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7542  at which function is defined.\n\
7543 ";
7544 static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
7545 Magnitude colored plot surface mesh with contour\n\
7546 \n\
7547 DESCRIPTION:\n\
7548 \n\
7549  A more powerful form of plmesh: the surface mesh can be colored\n\
7550  accordingly to the current z value being plotted, a contour plot can\n\
7551  be drawn at the base XY plane, and a curtain can be drawn between the\n\
7552  plotted function border and the base XY plane.\n\
7553 \n\
7554  Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7555 \n\
7556  This function is used in example 11.\n\
7557 \n\
7558 \n\
7559 \n\
7560 SYNOPSIS:\n\
7561 \n\
7562 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7563 \n\
7564 ARGUMENTS:\n\
7565 \n\
7566  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7567  which the function is evaluated.\n\
7568 \n\
7569  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7570  which the function is evaluated.\n\
7571 \n\
7572  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7573  plot. Should have dimensions of\n\
7574  nx by\n\
7575  ny.\n\
7576 \n\
7577  nx (PLINT, input) : Number of x values at which function is\n\
7578  evaluated.\n\
7579 \n\
7580  ny (PLINT, input) : Number of y values at which function is\n\
7581  evaluated.\n\
7582 \n\
7583  opt (PLINT, input) : Determines the way in which the surface is\n\
7584  represented. To specify more than one option just add the options,\n\
7585  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7586  showing z as a function of x for each value of y[j] .\n\
7587  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7588  for each value of x[i] .\n\
7589  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7590  at which function is defined.\n\
7591  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7592  the z value being plotted. The color is used from the current\n\
7593  cmap1.\n\
7594  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7595  using parameters\n\
7596  nlevel and\n\
7597  clevel.\n\
7598  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7599  the borders of the plotted function.\n\
7600 \n\
7601 \n\
7602  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7603  levels.\n\
7604 \n\
7605  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7606 ";
7607 static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
7608 End plotting session for current stream\n\
7609 \n\
7610 DESCRIPTION:\n\
7611 \n\
7612  Ends a plotting session for the current output stream only. See\n\
7613  plsstrm for more info.\n\
7614 \n\
7615  Redacted form: plend1()\n\
7616 \n\
7617  This function is used in examples 1 and 20.\n\
7618 \n\
7619 \n\
7620 \n\
7621 SYNOPSIS:\n\
7622 \n\
7623 plend1()\n\
7624 ";
7625 static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
7626 Get y axis parameters\n\
7627 \n\
7628 DESCRIPTION:\n\
7629 \n\
7630  Identical to plgxax, except that arguments are flags for y axis. See\n\
7631  the description of plgxax for more detail.\n\
7632 \n\
7633  Redacted form: plgyax(p_digmax, p_digits)\n\
7634 \n\
7635  This function is used in example 31.\n\
7636 \n\
7637 \n\
7638 \n\
7639 SYNOPSIS:\n\
7640 \n\
7641 plgyax(p_digmax, p_digits)\n\
7642 \n\
7643 ARGUMENTS:\n\
7644 \n\
7645  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7646  number of digits for the y axis. If nonzero, the printed label\n\
7647  has been switched to a floating-point representation when the\n\
7648  number of digits exceeds this value.\n\
7649 \n\
7650  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7651  number of digits for the numeric labels (y axis) from the last\n\
7652  plot.\n\
7653 ";
7654 static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
7655 Set plot orientation\n\
7656 \n\
7657 DESCRIPTION:\n\
7658 \n\
7659  Set plot orientation parameter which is multiplied by 90 degrees to\n\
7660  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7661  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7662  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7663  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7664  (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7665  not called the default value of rot is 0.\n\
7666 \n\
7667  N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7668  probably want to change the aspect ratio to a value suitable for the\n\
7669  plot orientation using a call to plsdidev or the command-line options\n\
7670  -a or -freeaspect. For more documentation of those options see the\n\
7671  PLplot documentation. Such command-line options can be set internally\n\
7672  using plsetopt or set directly using the command line and parsed using\n\
7673  a call to plparseopts.\n\
7674 \n\
7675  Redacted form: plsdiori(rot)\n\
7676 \n\
7677  This function is not used in any examples.\n\
7678 \n\
7679 \n\
7680 \n\
7681 SYNOPSIS:\n\
7682 \n\
7683 plsdiori(rot)\n\
7684 \n\
7685 ARGUMENTS:\n\
7686 \n\
7687  rot (PLFLT, input) : Plot orientation parameter.\n\
7688 ";
7689 static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7690 Plot a histogram from unbinned data\n\
7691 \n\
7692 DESCRIPTION:\n\
7693 \n\
7694  Plots a histogram from n data points stored in the data vector. This\n\
7695  routine bins the data into nbin bins equally spaced between datmin and\n\
7696  datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7697  opt allows, among other things, the histogram either to be plotted in\n\
7698  an existing window or causes plhist to call plenv with suitable limits\n\
7699  before plotting the histogram.\n\
7700 \n\
7701  Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7702 \n\
7703  This function is used in example 5.\n\
7704 \n\
7705 \n\
7706 \n\
7707 SYNOPSIS:\n\
7708 \n\
7709 plhist(n, data, datmin, datmax, nbin, opt)\n\
7710 \n\
7711 ARGUMENTS:\n\
7712 \n\
7713  n (PLINT, input) : Number of data points.\n\
7714 \n\
7715  data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7716  n data points.\n\
7717 \n\
7718  datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7719 \n\
7720  datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7721 \n\
7722  nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7723  divide the interval xmin to xmax.\n\
7724 \n\
7725  opt (PLINT, input) : Is a combination of several flags:\n\
7726  opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7727  the histogram data, the outer bins are expanded to fill up the\n\
7728  entire x-axis, data outside the given extremes are assigned to the\n\
7729  outer bins and bins of zero height are simply drawn.\n\
7730  opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7731  to fit the histogram data, without this flag, plenv is called\n\
7732  to set the world coordinates.\n\
7733  opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7734  extremes are not taken into account. This option should\n\
7735  probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7736  properly present the data.\n\
7737  opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7738  size as the ones inside.\n\
7739  opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7740  (there is a gap for such bins).\n\
7741 ";
7742 static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
7743 End plotting session\n\
7744 \n\
7745 DESCRIPTION:\n\
7746 \n\
7747  Ends a plotting session, tidies up all the output files, switches\n\
7748  interactive devices back into text mode and frees up any memory that\n\
7749  was allocated. Must be called before end of program.\n\
7750 \n\
7751  By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7752  wait state after a call to plend or other functions which trigger the\n\
7753  end of a plot page. To avoid this, use the plspause function.\n\
7754 \n\
7755  Redacted form: plend()\n\
7756 \n\
7757  This function is used in all of the examples.\n\
7758 \n\
7759 \n\
7760 \n\
7761 SYNOPSIS:\n\
7762 \n\
7763 plend()\n\
7764 ";
7765 static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
7766 Plot shaded 3-d surface plot\n\
7767 \n\
7768 DESCRIPTION:\n\
7769 \n\
7770  Plots a three-dimensional shaded surface plot within the environment\n\
7771  set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7772  z[\n\
7773  nx][\n\
7774  ny], the point z[i][j] being the value of the function at (\n\
7775  x[i],\n\
7776  y[j]). Note that the points in vectors x and y do not need to be\n\
7777  equally spaced, but must be stored in ascending order. For further\n\
7778  details see the PLplot documentation.\n\
7779 \n\
7780  Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7781 \n\
7782  This function is not used in any examples.\n\
7783 \n\
7784 \n\
7785 \n\
7786 SYNOPSIS:\n\
7787 \n\
7788 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7789 \n\
7790 ARGUMENTS:\n\
7791 \n\
7792  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7793  which the function is evaluated.\n\
7794 \n\
7795  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7796  which the function is evaluated.\n\
7797 \n\
7798  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7799  plot. Should have dimensions of\n\
7800  nx by\n\
7801  ny.\n\
7802 \n\
7803  nx (PLINT, input) : Number of x values at which function is\n\
7804  evaluated.\n\
7805 \n\
7806  ny (PLINT, input) : Number of y values at which function is\n\
7807  evaluated.\n\
7808 \n\
7809  opt (PLINT, input) : Determines the way in which the surface is\n\
7810  represented. To specify more than one option just add the options,\n\
7811  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7812  connecting points at which function is defined.\n\
7813  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7814  using parameters\n\
7815  nlevel and\n\
7816  clevel.\n\
7817  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7818  using parameters\n\
7819  nlevel and\n\
7820  clevel.\n\
7821  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7822  the borders of the plotted function.\n\
7823  opt=MAG_COLOR : the surface is colored according to the value\n\
7824  of Z; if MAG_COLOR is not used, then the surface is colored\n\
7825  according to the intensity of the reflected light in the\n\
7826  surface from a light source whose position is set using\n\
7827  pllightsource.\n\
7828 \n\
7829 \n\
7830  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7831  levels.\n\
7832 \n\
7833  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7834 ";
7835 static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
7836 Set device-compression level\n\
7837 \n\
7838 DESCRIPTION:\n\
7839 \n\
7840  Set device-compression level. Only used for drivers that provide\n\
7841  compression. This function, if used, should be invoked before a call\n\
7842  to plinit.\n\
7843 \n\
7844  Redacted form: plscompression(compression)\n\
7845 \n\
7846  This function is used in example 31.\n\
7847 \n\
7848 \n\
7849 \n\
7850 SYNOPSIS:\n\
7851 \n\
7852 plscompression(compression)\n\
7853 \n\
7854 ARGUMENTS:\n\
7855 \n\
7856  compression (PLINT, input) : The desired compression level. This is\n\
7857  a device-dependent value. Currently only the jpeg and png devices\n\
7858  use these values. For jpeg value is the jpeg quality which should\n\
7859  normally be in the range 0-95. Higher values denote higher quality\n\
7860  and hence larger image sizes. For png values are in the range -1\n\
7861  to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7862  A value of -1 denotes the default zlib compression level. Values\n\
7863  in the range 10-99 are divided by 10 and then used as the zlib\n\
7864  compression level. Higher compression levels correspond to greater\n\
7865  compression and small file sizes at the expense of more\n\
7866  computation.\n\
7867 ";
7868 static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
7869 Get the current device-compression setting\n\
7870 \n\
7871 DESCRIPTION:\n\
7872 \n\
7873  Get the current device-compression setting. This parameter is only\n\
7874  used for drivers that provide compression.\n\
7875 \n\
7876  Redacted form: plgcompression(compression)\n\
7877 \n\
7878  This function is used in example 31.\n\
7879 \n\
7880 \n\
7881 \n\
7882 SYNOPSIS:\n\
7883 \n\
7884 plgcompression(compression)\n\
7885 \n\
7886 ARGUMENTS:\n\
7887 \n\
7888  compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7889  compression setting for the current device.\n\
7890 ";
7891 static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
7892 Advance the (sub-)page\n\
7893 \n\
7894 DESCRIPTION:\n\
7895 \n\
7896  Advances to the next subpage if sub=0, performing a page advance if\n\
7897  there are no remaining subpages on the current page. If subpages\n\
7898  aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7899  PLplot switches to the specified subpage. Note that this allows you\n\
7900  to overwrite a plot on the specified subpage; if this is not what you\n\
7901  intended, use pleop followed by plbop to first advance the page. This\n\
7902  routine is called automatically (with page=0) by plenv, but if plenv\n\
7903  is not used, pladv must be called after initializing PLplot but before\n\
7904  defining the viewport.\n\
7905 \n\
7906  Redacted form: pladv(page)\n\
7907 \n\
7908  This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7909  29, and 31.\n\
7910 \n\
7911 \n\
7912 \n\
7913 SYNOPSIS:\n\
7914 \n\
7915 pladv(page)\n\
7916 \n\
7917 ARGUMENTS:\n\
7918 \n\
7919  page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7920  in the top left corner and increasing along the rows) to which to\n\
7921  advance. Set to zero to advance to the next subpage (or to the\n\
7922  next page if subpages are not being used).\n\
7923 ";
7924 static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7925 Set parameters of contour labelling other than format of numerical label\n\
7926 \n\
7927 DESCRIPTION:\n\
7928 \n\
7929  Set parameters of contour labelling other than those handled by\n\
7930  pl_setcontlabelformat.\n\
7931 \n\
7932  Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7933 \n\
7934  This function is used in example 9.\n\
7935 \n\
7936 \n\
7937 \n\
7938 SYNOPSIS:\n\
7939 \n\
7940 pl_setcontlabelparam(offset, size, spacing, active)\n\
7941 \n\
7942 ARGUMENTS:\n\
7943 \n\
7944  offset (PLFLT, input) : Offset of label from contour line (if set\n\
7945  to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7946 \n\
7947  size (PLFLT, input) : Font height for contour labels (normalized).\n\
7948  Default value is 0.3.\n\
7949 \n\
7950  spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7951  Default value is 0.1.\n\
7952 \n\
7953  active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7954  contour labels on. Default is off (0).\n\
7955 ";
7956 static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
7957 Set family, style and weight of the current font\n\
7958 \n\
7959 DESCRIPTION:\n\
7960 \n\
7961  Sets the current font. See the PLplot documentation for more\n\
7962  information on font selection.\n\
7963 \n\
7964  Redacted form: plsfont(family, style, weight)\n\
7965 \n\
7966  This function is used in example 23.\n\
7967 \n\
7968 \n\
7969 \n\
7970 SYNOPSIS:\n\
7971 \n\
7972 plsfont(family, style, weight)\n\
7973 \n\
7974 ARGUMENTS:\n\
7975 \n\
7976  family (PLINT, input) : Font family to select for the current font.\n\
7977  The available values are given by the PL_FCI_* constants in\n\
7978  plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7979  PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7980  signifies that the font family should not be altered.\n\
7981 \n\
7982  style (PLINT, input) : Font style to select for the current font.\n\
7983  The available values are given by the PL_FCI_* constants in\n\
7984  plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7985  PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7986  should not be altered.\n\
7987 \n\
7988  weight (PLINT, input) : Font weight to select for the current font.\n\
7989  The available values are given by the PL_FCI_* constants in\n\
7990  plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7991  negative value signifies that the font weight should not be\n\
7992  altered.\n\
7993 ";
7994 static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
7995 Sets the 3D position of the light source\n\
7996 \n\
7997 DESCRIPTION:\n\
7998 \n\
7999  Sets the 3D position of the light source for use with plsurf3d and\n\
8000  plsurf3dl\n\
8001 \n\
8002  Redacted form: pllightsource(x, y, z)\n\
8003 \n\
8004  This function is used in example 8.\n\
8005 \n\
8006 \n\
8007 \n\
8008 SYNOPSIS:\n\
8009 \n\
8010 pllightsource(x, y, z)\n\
8011 \n\
8012 ARGUMENTS:\n\
8013 \n\
8014  x (PLFLT, input) : X-coordinate of the light source.\n\
8015 \n\
8016  y (PLFLT, input) : Y-coordinate of the light source.\n\
8017 \n\
8018  z (PLFLT, input) : Z-coordinate of the light source.\n\
8019 ";
8020 static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
8021 Draw a line\n\
8022 \n\
8023 DESCRIPTION:\n\
8024 \n\
8025  Draws line defined by n points in x and y.\n\
8026 \n\
8027  Redacted form: plline(x, y)\n\
8028 \n\
8029  This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
8030  25-27, and 29.\n\
8031 \n\
8032 \n\
8033 \n\
8034 SYNOPSIS:\n\
8035 \n\
8036 plline(n, x, y)\n\
8037 \n\
8038 ARGUMENTS:\n\
8039 \n\
8040  n (PLINT, input) : Number of points defining line.\n\
8041 \n\
8042  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8043  points.\n\
8044 \n\
8045  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8046  points.\n\
8047 ";
8048 static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
8049 Set pen width\n\
8050 \n\
8051 DESCRIPTION:\n\
8052 \n\
8053  Sets the pen width.\n\
8054 \n\
8055  Redacted form: plwidth(width)\n\
8056 \n\
8057  This function is used in examples 1 and 2.\n\
8058 \n\
8059 \n\
8060 \n\
8061 SYNOPSIS:\n\
8062 \n\
8063 plwidth(width)\n\
8064 \n\
8065 ARGUMENTS:\n\
8066 \n\
8067  width (PLFLT, input) : The desired pen width. If width is negative\n\
8068  or the same as the previous value no action is taken. width = 0.\n\
8069  should be interpreted as as the minimum valid pen width for the\n\
8070  device. The interpretation of positive width values is also\n\
8071  device dependent.\n\
8072 ";
8073 static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
8074 Draw linear gradient inside polygon\n\
8075 \n\
8076 DESCRIPTION:\n\
8077 \n\
8078  Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
8079  points (\n\
8080  x[i],\n\
8081  y[i]). Interpretation of the polygon is the same as for plfill. The\n\
8082  polygon coordinates and the gradient angle are all expressed in world\n\
8083  coordinates. The angle from the x axis for both the rotated\n\
8084  coordinate system and the gradient vector is specified by angle. The\n\
8085  magnitude of the gradient vector is the difference between the maximum\n\
8086  and minimum values of x for the vertices in the rotated coordinate\n\
8087  system. The origin of the gradient vector can be interpreted as being\n\
8088  anywhere on the line corresponding to the minimum x value for the\n\
8089  vertices in the rotated coordinate system. The distance along the\n\
8090  gradient vector is linearly transformed to the independent variable of\n\
8091  color map 1 which ranges from 0. at the tail of the gradient vector to\n\
8092  1. at the head of the gradient vector. What is drawn is the RGBA\n\
8093  color corresponding to the independent variable of cmap1. For more\n\
8094  information about cmap1 (see the PLplot documentation).\n\
8095 \n\
8096  Redacted form: plgradient(x,y,angle)\n\
8097 \n\
8098  This function is used in examples 25 and 30.\n\
8099 \n\
8100 \n\
8101 \n\
8102 SYNOPSIS:\n\
8103 \n\
8104 plgradient(n, x, y, angle)\n\
8105 \n\
8106 ARGUMENTS:\n\
8107 \n\
8108  n (PLINT, input) : Number of vertices in polygon.\n\
8109 \n\
8110  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8111  vertices.\n\
8112 \n\
8113  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8114  vertices.\n\
8115 \n\
8116  angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
8117  axis.\n\
8118 ";
8119 static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
8120 Flushes the output stream\n\
8121 \n\
8122 DESCRIPTION:\n\
8123 \n\
8124  Flushes the output stream. Use sparingly, if at all.\n\
8125 \n\
8126  Redacted form: plflush()\n\
8127 \n\
8128  This function is used in examples 1 and 14.\n\
8129 \n\
8130 \n\
8131 \n\
8132 SYNOPSIS:\n\
8133 \n\
8134 plflush()\n\
8135 ";
8136 static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
8137 Get plot orientation\n\
8138 \n\
8139 DESCRIPTION:\n\
8140 \n\
8141  Get plot orientation parameter which is multiplied by 90 degrees to\n\
8142  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
8143  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
8144  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
8145  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
8146  (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
8147  not been called the default value pointed to by p_rot will be 0.\n\
8148 \n\
8149  Redacted form: plgdiori(p_rot)\n\
8150 \n\
8151  This function is not used in any examples.\n\
8152 \n\
8153 \n\
8154 \n\
8155 SYNOPSIS:\n\
8156 \n\
8157 plgdiori(p_rot)\n\
8158 \n\
8159 ARGUMENTS:\n\
8160 \n\
8161  p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
8162  parameter.\n\
8163 ";
8164 static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
8165 Set x axis parameters\n\
8166 \n\
8167 DESCRIPTION:\n\
8168 \n\
8169  Sets values of the digmax and digits flags for the x axis. See the\n\
8170  PLplot documentation for more information.\n\
8171 \n\
8172  Redacted form: plsxax(digmax, digits)\n\
8173 \n\
8174  This function is used in example 31.\n\
8175 \n\
8176 \n\
8177 \n\
8178 SYNOPSIS:\n\
8179 \n\
8180 plsxax(digmax, digits)\n\
8181 \n\
8182 ARGUMENTS:\n\
8183 \n\
8184  digmax (PLINT, input) : Variable to set the maximum number of\n\
8185  digits for the x axis. If nonzero, the printed label will be\n\
8186  switched to a floating-point representation when the number of\n\
8187  digits exceeds digmax.\n\
8188 \n\
8189  digits (PLINT, input) : Field digits value. Currently, changing\n\
8190  its value here has no effect since it is set only by plbox or\n\
8191  plbox3. However, the user may obtain its value after a call to\n\
8192  either of these functions by calling plgxax.\n\
8193 ";
8194 static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
8195 Get viewport limits in world coordinates\n\
8196 \n\
8197 DESCRIPTION:\n\
8198 \n\
8199  Get viewport limits in world coordinates.\n\
8200 \n\
8201  Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8202 \n\
8203 \n\
8204  This function is used in example 31.\n\
8205 \n\
8206 \n\
8207 \n\
8208 SYNOPSIS:\n\
8209 \n\
8210 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8211 \n\
8212 ARGUMENTS:\n\
8213 \n\
8214  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8215  viewport limit of the world coordinate in x.\n\
8216 \n\
8217  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8218  viewport limit of the world coordinate in x.\n\
8219 \n\
8220  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8221  viewport limit of the world coordinate in y.\n\
8222 \n\
8223  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8224  viewport limit of the world coordinate in y.\n\
8225 ";
8226 static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
8227 Shade regions on the basis of value\n\
8228 \n\
8229 DESCRIPTION:\n\
8230 \n\
8231  Shade regions on the basis of value. This is the high-level routine\n\
8232  for making continuous color shaded plots with cmap1 while plshade\n\
8233  should be used to plot individual shaded regions using either cmap0 or\n\
8234  cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
8235  our supported languages.\n\
8236 \n\
8237  Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
8238  clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
8239  pltr_data)\n\
8240 \n\
8241 \n\
8242  This function is used in examples 16, 21, and 22.\n\
8243 \n\
8244 \n\
8245 \n\
8246 SYNOPSIS:\n\
8247 \n\
8248 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
8249 \n\
8250 ARGUMENTS:\n\
8251 \n\
8252  a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8253  plot. Should have dimensions of\n\
8254  nx by\n\
8255  ny.\n\
8256 \n\
8257  nx (PLINT, input) : First dimension of matrix \"a\".\n\
8258 \n\
8259  ny (PLINT, input) : Second dimension of matrix \"a\".\n\
8260 \n\
8261  defined (PLDEFINED_callback, input) : Callback function specifying\n\
8262  the region that should be plotted in the shade plot. This\n\
8263  function accepts x and y coordinates as input arguments and must\n\
8264  return 1 if the point is to be included in the shade plot and 0\n\
8265  otherwise. If you want to plot the entire shade plot (the usual\n\
8266  case), this argument should be set to NULL.\n\
8267 \n\
8268  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8269  pltr below for how these arguments are used (only for the special case\n\
8270  when the callback function\n\
8271  pltr is not supplied).\n\
8272 \n\
8273  clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
8274  corresponding to the edges of each shaded region that will be\n\
8275  plotted by this function. To work properly the levels should be\n\
8276  monotonic.\n\
8277 \n\
8278  nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
8279  of shade edge values in clevel).\n\
8280 \n\
8281  fill_width (PLFLT, input) : Defines the line width used by the fill\n\
8282  pattern.\n\
8283 \n\
8284  cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
8285  contours defining edges of shaded regions. The pen color is only\n\
8286  temporary set for the contour drawing. Set this value to zero or\n\
8287  less if no shade edge contours are wanted.\n\
8288 \n\
8289  cont_width (PLFLT, input) : Defines line width used for contours\n\
8290  defining edges of shaded regions. This value may not be honored\n\
8291  by all drivers. The pen width is only temporary set for the\n\
8292  contour drawing. Set this value to zero or less if no shade edge\n\
8293  contours are wanted.\n\
8294 \n\
8295  fill (PLFILL_callback, input) : Callback routine used to fill the\n\
8296  region. Use plfill for this purpose.\n\
8297 \n\
8298  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8299  map to rectangles after coordinate transformation with pltrl.\n\
8300  Otherwise, set rectangular to false. If rectangular is set to\n\
8301  true, plshade tries to save time by filling large rectangles.\n\
8302  This optimization fails if the coordinate transformation distorts\n\
8303  the shape of rectangles. For example a plot in polar coordinates\n\
8304  has to have rectangular set to false.\n\
8305 \n\
8306  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8307  defines the transformation between the zero-based indices of the\n\
8308  matrix a and world coordinates. If\n\
8309  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8310  indices of a are mapped to the range\n\
8311  xmin through\n\
8312  xmax and the y indices of a are mapped to the range\n\
8313  ymin through\n\
8314  ymax.For the C case, transformation functions are provided in the\n\
8315  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8316  pltr2 for arbitrary mappings respectively defined by vectors and\n\
8317  matrices. In addition, C callback routines for the transformation\n\
8318  can be supplied by the user such as the mypltr function in\n\
8319  examples/c/x09c.c which provides a general linear transformation\n\
8320  between index coordinates and world coordinates.For languages\n\
8321  other than C you should consult the PLplot documentation for the\n\
8322  details concerning how PLTRANSFORM_callback arguments are\n\
8323  interfaced. However, in general, a particular pattern of\n\
8324  callback-associated arguments such as a tr vector with 6 elements;\n\
8325  xg and yg vectors; or xg and yg matrices are respectively\n\
8326  interfaced to a linear-transformation routine similar to the above\n\
8327  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8328  sophisticated bindings (see, e.g., the PLplot documentation)\n\
8329  support native language callbacks for handling index to\n\
8330  world-coordinate transformations. Examples of these various\n\
8331  approaches are given in examples/<language>x09*,\n\
8332  examples/<language>x16*, examples/<language>x20*,\n\
8333  examples/<language>x21*, and examples/<language>x22*, for all our\n\
8334  supported languages.\n\
8335 \n\
8336  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8337  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8338  externally supplied.\n\
8339 ";
8340 static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
8341 Plot color bar for image, shade or gradient plots\n\
8342 \n\
8343 DESCRIPTION:\n\
8344 \n\
8345  Routine for creating a continuous color bar for image, shade, or\n\
8346  gradient plots. (See pllegend for similar functionality for creating\n\
8347  legends with discrete elements). The arguments of plcolorbar provide\n\
8348  control over the location and size of the color bar as well as the\n\
8349  location and characteristics of the elements (most of which are\n\
8350  optional) within that color bar. The resulting color bar is clipped\n\
8351  at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
8352  system used for some of the parameters is defined in the documentation\n\
8353  of the position parameter.)\n\
8354 \n\
8355  Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
8356  position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
8357  low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
8358  labels, axis_opts, ticks, sub_ticks, values)\n\
8359 \n\
8360  This function is used in examples 16 and 33.\n\
8361 \n\
8362 \n\
8363 \n\
8364 SYNOPSIS:\n\
8365 \n\
8366 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\
8367 \n\
8368 ARGUMENTS:\n\
8369 \n\
8370  p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8371  labelled and decorated color bar width in adopted coordinates.\n\
8372 \n\
8373  p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8374  labelled and decorated color bar height in adopted coordinates.\n\
8375 \n\
8376  opt (PLINT, input) : opt contains bits controlling the overall\n\
8377  color bar. The orientation (direction of the maximum value) of\n\
8378  the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
8379  PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
8380  specified, the default orientation is toward the top if the\n\
8381  colorbar is placed on the left or right of the viewport or toward\n\
8382  the right if the colorbar is placed on the top or bottom of the\n\
8383  viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
8384  (semitransparent) background for the color bar. If the\n\
8385  PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8386  color bar. The type of color bar must be specified with one of\n\
8387  PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
8388  more than one of those bits is set only the first one in the above\n\
8389  list is honored. The position of the (optional) label/title can be\n\
8390  specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
8391  PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
8392  will be drawn. If more than one of this list of bits is specified,\n\
8393  only the first one on the list is honored. End-caps for the color\n\
8394  bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
8395  If a particular color bar cap option is not specified then no cap\n\
8396  will be drawn for that end. As a special case for\n\
8397  PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
8398  specified. If this option is provided then any tick marks and tick\n\
8399  labels will be placed at the breaks between shaded segments. TODO:\n\
8400  This should be expanded to support custom placement of tick marks\n\
8401  and tick labels at custom value locations for any color bar type.\n\
8402 \n\
8403  position (PLINT, input) : position contains bits which control the\n\
8404  overall position of the color bar and the definition of the\n\
8405  adopted coordinates used for positions just like what is done for\n\
8406  the position argument for pllegend. However, note that the\n\
8407  defaults for the position bits (see below) are different than the\n\
8408  pllegend case. The combination of the PL_POSITION_LEFT,\n\
8409  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8410  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8411  the 16 possible standard positions (the 4 corners and centers of\n\
8412  the 4 sides for both the inside and outside cases) of the color\n\
8413  bar relative to the adopted coordinate system. The corner\n\
8414  positions are specified by the appropriate combination of two of\n\
8415  the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8416  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8417  value of one of those bits. The adopted coordinates are\n\
8418  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8419  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8420  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8421  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8422  then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
8423  PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
8424  PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
8425  PL_POSITION_VIEWPORT.\n\
8426 \n\
8427  x (PLFLT, input) : X offset of the color bar position in adopted\n\
8428  coordinates from the specified standard position of the color bar.\n\
8429  For positive x, the direction of motion away from the standard\n\
8430  position is inward/outward from the standard corner positions or\n\
8431  standard left or right positions if the\n\
8432  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8433  For the standard top or bottom positions, the direction of motion\n\
8434  is toward positive X.\n\
8435 \n\
8436  y (PLFLT, input) : Y offset of the color bar position in adopted\n\
8437  coordinates from the specified standard position of the color bar.\n\
8438  For positive y, the direction of motion away from the standard\n\
8439  position is inward/outward from the standard corner positions or\n\
8440  standard top or bottom positions if the\n\
8441  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8442  For the standard left or right positions, the direction of motion\n\
8443  is toward positive Y.\n\
8444 \n\
8445  x_length (PLFLT, input) : Length of the body of the color bar in\n\
8446  the X direction in adopted coordinates.\n\
8447 \n\
8448  y_length (PLFLT, input) : Length of the body of the color bar in\n\
8449  the Y direction in adopted coordinates.\n\
8450 \n\
8451  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8452  color bar (PL_COLORBAR_BACKGROUND).\n\
8453 \n\
8454  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8455  for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8456 \n\
8457  bb_style (PLINT, input) : The pllsty style number for the\n\
8458  bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8459 \n\
8460  low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8461  bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8462 \n\
8463  high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8464  color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8465 \n\
8466  cont_color (PLINT, input) : The cmap0 contour color for\n\
8467  PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8468  it will be interpreted according to the design of plshades.\n\
8469 \n\
8470  cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8471  plots. This is passed directly to plshades, so it will be\n\
8472  interpreted according to the design of plshades.\n\
8473 \n\
8474  n_labels (PLINT, input) : Number of labels to place around the\n\
8475  color bar.\n\
8476 \n\
8477  label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8478  n_labels labels.\n\
8479 \n\
8480  labels (PLCHAR_MATRIX, input) : A vector of\n\
8481  n_labels UTF-8 character strings containing the labels for the color\n\
8482  bar. Ignored if no label position is specified with one of the\n\
8483  PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8484  PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8485  corresponding label_opts field.\n\
8486 \n\
8487  n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8488  value must be greater than 0. It is typically 1 (numerical axis\n\
8489  labels are provided for one of the long edges of the color bar),\n\
8490  but it can be larger if multiple numerical axis labels for the\n\
8491  long edges of the color bar are desired.\n\
8492 \n\
8493  axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8494  n_axes ascii character strings containing options (interpreted as for\n\
8495  plbox) for the color bar\'s axis definitions.\n\
8496 \n\
8497  ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8498  spacing of the major tick marks (interpreted as for plbox) for the\n\
8499  color bar\'s axis definitions.\n\
8500 \n\
8501  sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8502  number of subticks (interpreted as for plbox) for the color bar\'s\n\
8503  axis definitions.\n\
8504 \n\
8505  n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8506  elements in each of the n_axes rows of the values matrix.\n\
8507 \n\
8508  values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8509  values for the data range represented by the color bar. For a row\n\
8510  index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8511  elements in the row is specified by n_values[i_axis]. For\n\
8512  PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8513  is 2, and the corresponding row elements of the values matrix are\n\
8514  the minimum and maximum value represented by the colorbar. For\n\
8515  PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8516  of the values matrix is interpreted the same as the nlevel and\n\
8517  clevel arguments of plshades.\n\
8518 ";
8519 static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
8520 Get current subpage parameters\n\
8521 \n\
8522 DESCRIPTION:\n\
8523 \n\
8524  Gets the size of the current subpage in millimeters measured from the\n\
8525  bottom left hand corner of the output device page or screen. Can be\n\
8526  used in conjunction with plsvpa for setting the size of a viewport in\n\
8527  absolute coordinates (millimeters).\n\
8528 \n\
8529  Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8530 \n\
8531  This function is used in example 23.\n\
8532 \n\
8533 \n\
8534 \n\
8535 SYNOPSIS:\n\
8536 \n\
8537 plgspa(xmin, xmax, ymin, ymax)\n\
8538 \n\
8539 ARGUMENTS:\n\
8540 \n\
8541  xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8542  the left hand edge of the subpage in millimeters.\n\
8543 \n\
8544  xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8545  the right hand edge of the subpage in millimeters.\n\
8546 \n\
8547  ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8548  the bottom edge of the subpage in millimeters.\n\
8549 \n\
8550  ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8551  the top edge of the subpage in millimeters.\n\
8552 ";
8553 static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
8554 Shade individual region on the basis of value\n\
8555 \n\
8556 DESCRIPTION:\n\
8557 \n\
8558  Shade individual region on the basis of value. Use plshades if you\n\
8559  want to shade a number of contiguous regions using continuous colors.\n\
8560  In particular the edge contours are treated properly in plshades. If\n\
8561  you attempt to do contiguous regions with plshade the contours at the\n\
8562  edge of the shade are partially obliterated by subsequent plots of\n\
8563  contiguous shaded regions.\n\
8564 \n\
8565  Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8566  shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8567  min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8568 \n\
8569 \n\
8570  This function is used in example 15.\n\
8571 \n\
8572 \n\
8573 \n\
8574 SYNOPSIS:\n\
8575 \n\
8576 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\
8577 \n\
8578 ARGUMENTS:\n\
8579 \n\
8580  a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8581  plot. Should have dimensions of\n\
8582  nx by\n\
8583  ny.\n\
8584 \n\
8585  nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8586 \n\
8587  ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8588 \n\
8589  defined (PLDEFINED_callback, input) : Callback function specifying\n\
8590  the region that should be plotted in the shade plot. This\n\
8591  function accepts x and y coordinates as input arguments and must\n\
8592  return 1 if the point is to be included in the shade plot and 0\n\
8593  otherwise. If you want to plot the entire shade plot (the usual\n\
8594  case), this argument should be set to NULL.\n\
8595 \n\
8596  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8597  pltr below for how these arguments are used (only for the special case\n\
8598  when the callback function\n\
8599  pltr is not supplied).\n\
8600 \n\
8601  shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8602  be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8603 \n\
8604  shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8605  be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8606 \n\
8607  sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8608  sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8609  then sh_color is interpreted as a cmap1 argument in the range\n\
8610  (0.0-1.0).\n\
8611 \n\
8612  sh_color (PLFLT, input) : Defines color map index with integer\n\
8613  value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8614 \n\
8615  sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8616 \n\
8617  min_color (PLINT, input) : Defines pen color, width used by the\n\
8618  boundary of shaded region. The min values are used for the\n\
8619  shade_min boundary, and the max values are used on the shade_max\n\
8620  boundary. Set color and width to zero for no plotted boundaries.\n\
8621 \n\
8622  min_width (PLFLT, input) : Defines pen color, width used by the\n\
8623  boundary of shaded region. The min values are used for the\n\
8624  shade_min boundary, and the max values are used on the shade_max\n\
8625  boundary. Set color and width to zero for no plotted boundaries.\n\
8626 \n\
8627  max_color (PLINT, input) : Defines pen color, width used by the\n\
8628  boundary of shaded region. The min values are used for the\n\
8629  shade_min boundary, and the max values are used on the shade_max\n\
8630  boundary. Set color and width to zero for no plotted boundaries.\n\
8631 \n\
8632  max_width (PLFLT, input) : Defines pen color, width used by the\n\
8633  boundary of shaded region. The min values are used for the\n\
8634  shade_min boundary, and the max values are used on the shade_max\n\
8635  boundary. Set color and width to zero for no plotted boundaries.\n\
8636 \n\
8637  fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8638  Use plfill. Future version of PLplot may have other fill\n\
8639  routines.\n\
8640 \n\
8641  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8642  map to rectangles after coordinate transformation with pltrl.\n\
8643  Otherwise, set rectangular to false. If rectangular is set to\n\
8644  true, plshade tries to save time by filling large rectangles.\n\
8645  This optimization fails if the coordinate transformation distorts\n\
8646  the shape of rectangles. For example a plot in polar coordinates\n\
8647  has to have rectangular set to false.\n\
8648 \n\
8649  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8650  defines the transformation between the zero-based indices of the\n\
8651  matrix a and world coordinates. If\n\
8652  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8653  indices of a are mapped to the range\n\
8654  xmin through\n\
8655  xmax and the y indices of a are mapped to the range\n\
8656  ymin through\n\
8657  ymax.For the C case, transformation functions are provided in the\n\
8658  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8659  pltr2 for arbitrary mappings respectively defined by vectors and\n\
8660  matrices. In addition, C callback routines for the transformation\n\
8661  can be supplied by the user such as the mypltr function in\n\
8662  examples/c/x09c.c which provides a general linear transformation\n\
8663  between index coordinates and world coordinates.For languages\n\
8664  other than C you should consult the PLplot documentation for the\n\
8665  details concerning how PLTRANSFORM_callback arguments are\n\
8666  interfaced. However, in general, a particular pattern of\n\
8667  callback-associated arguments such as a tr vector with 6 elements;\n\
8668  xg and yg vectors; or xg and yg matrices are respectively\n\
8669  interfaced to a linear-transformation routine similar to the above\n\
8670  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8671  sophisticated bindings (see, e.g., the PLplot documentation)\n\
8672  support native language callbacks for handling index to\n\
8673  world-coordinate transformations. Examples of these various\n\
8674  approaches are given in examples/<language>x09*,\n\
8675  examples/<language>x16*, examples/<language>x20*,\n\
8676  examples/<language>x21*, and examples/<language>x22*, for all our\n\
8677  supported languages.\n\
8678 \n\
8679  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8680  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8681  externally supplied.\n\
8682 ";
8683 static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
8684 Calculate world coordinates and corresponding window index from relative device coordinates\n\
8685 \n\
8686 DESCRIPTION:\n\
8687 \n\
8688  Calculate world coordinates, wx and wy, and corresponding window index\n\
8689  from relative device coordinates, rx and ry.\n\
8690 \n\
8691  Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8692 \n\
8693 \n\
8694  This function is used in example 31.\n\
8695 \n\
8696 \n\
8697 \n\
8698 SYNOPSIS:\n\
8699 \n\
8700 plcalc_world(rx, ry, wx, wy, window)\n\
8701 \n\
8702 ARGUMENTS:\n\
8703 \n\
8704  rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8705  the x coordinate.\n\
8706 \n\
8707  ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8708  the y coordinate.\n\
8709 \n\
8710  wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8711  coordinate corresponding to the relative device coordinates rx and\n\
8712  ry.\n\
8713 \n\
8714  wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8715  coordinate corresponding to the relative device coordinates rx and\n\
8716  ry.\n\
8717 \n\
8718  window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8719  defined window index that corresponds to the input relative device\n\
8720  coordinates (and the returned world coordinates). To give some\n\
8721  background on the window index, for each page the initial window\n\
8722  index is set to zero, and each time plwind is called within the\n\
8723  page, world and device coordinates are stored for the window and\n\
8724  the window index is incremented. Thus, for a simple page layout\n\
8725  with non-overlapping viewports and one window per viewport, window\n\
8726  corresponds to the viewport index (in the order which the\n\
8727  viewport/windows were created) of the only viewport/window\n\
8728  corresponding to rx and ry. However, for more complicated layouts\n\
8729  with potentially overlapping viewports and possibly more than one\n\
8730  window (set of world coordinates) per viewport, window and the\n\
8731  corresponding output world coordinates corresponds to the last\n\
8732  window created that fulfills the criterion that the relative\n\
8733  device coordinates are inside it. Finally, in all cases where the\n\
8734  input relative device coordinates are not inside any\n\
8735  viewport/window, then the returned value of the last defined\n\
8736  window index is set to -1.\n\
8737 ";
8738 static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
8739 Draw a box with axes, etc, in 3-d\n\
8740 \n\
8741 DESCRIPTION:\n\
8742 \n\
8743  Draws axes, numeric and text labels for a three-dimensional surface\n\
8744  plot. For a more complete description of three-dimensional plotting\n\
8745  see the PLplot documentation.\n\
8746 \n\
8747  Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8748  ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8749 \n\
8750 \n\
8751  This function is used in examples 8, 11, 18, and 21.\n\
8752 \n\
8753 \n\
8754 \n\
8755 SYNOPSIS:\n\
8756 \n\
8757 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8758 \n\
8759 ARGUMENTS:\n\
8760 \n\
8761  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8762  options for the x axis. The string can include any combination of\n\
8763  the following letters (upper or lower case) in any order: b: Draws\n\
8764  axis at base, at height z=\n\
8765  zmin where zmin is defined by call to plw3d. This character must be\n\
8766  specified in order to use any of the other options.\n\
8767  d: Plot labels as date / time. Values are assumed to be\n\
8768  seconds since the epoch (as used by gmtime).\n\
8769  f: Always use fixed point numeric labels.\n\
8770  i: Inverts tick marks, so they are drawn downwards, rather\n\
8771  than upwards.\n\
8772  l: Labels axis logarithmically. This only affects the labels,\n\
8773  not the data, and so it is necessary to compute the logarithms\n\
8774  of data points before passing them to any of the drawing\n\
8775  routines.\n\
8776  n: Writes numeric labels at major tick intervals.\n\
8777  o: Use custom labelling function to generate axis label text.\n\
8778  The custom labelling function can be defined with the\n\
8779  plslabelfunc command.\n\
8780  s: Enables subticks between major ticks, only valid if t is\n\
8781  also specified.\n\
8782  t: Draws major ticks.\n\
8783  u: If this is specified, the text label for the axis is\n\
8784  written under the axis.\n\
8785 \n\
8786 \n\
8787  xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8788  the text label for the x axis. It is only drawn if u is in the\n\
8789  xopt string.\n\
8790 \n\
8791  xtick (PLFLT, input) : World coordinate interval between major\n\
8792  ticks on the x axis. If it is set to zero, PLplot automatically\n\
8793  generates a suitable tick interval.\n\
8794 \n\
8795  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8796  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8797  generates a suitable minor tick interval.\n\
8798 \n\
8799  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8800  options for the y axis. The string is interpreted in the same way\n\
8801  as xopt.\n\
8802 \n\
8803  ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8804  the text label for the y axis. It is only drawn if u is in the\n\
8805  yopt string.\n\
8806 \n\
8807  ytick (PLFLT, input) : World coordinate interval between major\n\
8808  ticks on the y axis. If it is set to zero, PLplot automatically\n\
8809  generates a suitable tick interval.\n\
8810 \n\
8811  nysub (PLINT, input) : Number of subintervals between major y axis\n\
8812  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8813  generates a suitable minor tick interval.\n\
8814 \n\
8815  zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8816  options for the z axis. The string can include any combination of\n\
8817  the following letters (upper or lower case) in any order: b: Draws\n\
8818  z axis to the left of the surface plot.\n\
8819  c: Draws z axis to the right of the surface plot.\n\
8820  d: Draws grid lines parallel to the x-y plane behind the\n\
8821  figure. These lines are not drawn until after plot3d or\n\
8822  plmesh are called because of the need for hidden line removal.\n\
8823  e: Plot labels as date / time. Values are assumed to be\n\
8824  seconds since the epoch (as used by gmtime). Note this\n\
8825  suboption is interpreted the same as the d suboption for xopt\n\
8826  and yopt, but it has to be identified as e for zopt since d\n\
8827  has already been used for the different purpose above.\n\
8828  f: Always use fixed point numeric labels.\n\
8829  i: Inverts tick marks, so they are drawn away from the center.\n\
8830  l: Labels axis logarithmically. This only affects the labels,\n\
8831  not the data, and so it is necessary to compute the logarithms\n\
8832  of data points before passing them to any of the drawing\n\
8833  routines.\n\
8834  m: Writes numeric labels at major tick intervals on the\n\
8835  right-hand z axis.\n\
8836  n: Writes numeric labels at major tick intervals on the\n\
8837  left-hand z axis.\n\
8838  o: Use custom labelling function to generate axis label text.\n\
8839  The custom labelling function can be defined with the\n\
8840  plslabelfunc command.\n\
8841  s: Enables subticks between major ticks, only valid if t is\n\
8842  also specified.\n\
8843  t: Draws major ticks.\n\
8844  u: If this is specified, the text label is written beside the\n\
8845  left-hand axis.\n\
8846  v: If this is specified, the text label is written beside the\n\
8847  right-hand axis.\n\
8848 \n\
8849 \n\
8850  zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8851  the text label for the z axis. It is only drawn if u or v are in\n\
8852  the zopt string.\n\
8853 \n\
8854  ztick (PLFLT, input) : World coordinate interval between major\n\
8855  ticks on the z axis. If it is set to zero, PLplot automatically\n\
8856  generates a suitable tick interval.\n\
8857 \n\
8858  nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8859  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8860  generates a suitable minor tick interval.\n\
8861 ";
8862 static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
8863 Get character default height and current (scaled) height\n\
8864 \n\
8865 DESCRIPTION:\n\
8866 \n\
8867  Get character default height and current (scaled) height.\n\
8868 \n\
8869  Redacted form: plgchr(p_def, p_ht)\n\
8870 \n\
8871  This function is used in example 23.\n\
8872 \n\
8873 \n\
8874 \n\
8875 SYNOPSIS:\n\
8876 \n\
8877 plgchr(p_def, p_ht)\n\
8878 \n\
8879 ARGUMENTS:\n\
8880 \n\
8881  p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8882  character height (mm).\n\
8883 \n\
8884  p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8885  character height (mm).\n\
8886 ";
8887 static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
8888 Set the escape character for text strings\n\
8889 \n\
8890 DESCRIPTION:\n\
8891 \n\
8892  Set the escape character for text strings. From C (in contrast to\n\
8893  Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
8894  characters are allowed to prevent the user from shooting himself in\n\
8895  the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
8896  use of backslash as a character escape). Here are the allowed escape\n\
8897  characters and their corresponding decimal ASCII values: !, ASCII 33\n\
8898  #, ASCII 35\n\
8899  $, ASCII 36\n\
8900  %, ASCII 37\n\
8901  &, ASCII 38\n\
8902  *, ASCII 42\n\
8903  @, ASCII 64\n\
8904  ^, ASCII 94\n\
8905  ~, ASCII 126\n\
8906 \n\
8907 \n\
8908  Redacted form: General: plsesc(esc)\n\
8909 \n\
8910 \n\
8911  This function is used in example 29.\n\
8912 \n\
8913 \n\
8914 \n\
8915 SYNOPSIS:\n\
8916 \n\
8917 plsesc(esc)\n\
8918 \n\
8919 ARGUMENTS:\n\
8920 \n\
8921  esc (char, input) : Escape character.\n\
8922 ";
8923 static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
8924 Draw a line between two points, accounting for coordinate transforms\n\
8925 \n\
8926 DESCRIPTION:\n\
8927 \n\
8928  Joins the point (\n\
8929  x1,\n\
8930  y1) to (\n\
8931  x2,\n\
8932  y2) . If a global coordinate transform is defined then the line is\n\
8933  broken in to n segments to approximate the path. If no transform is\n\
8934  defined then this simply acts like a call to pljoin.\n\
8935 \n\
8936  Redacted form: plpath(n,x1,y1,x2,y2)\n\
8937 \n\
8938  This function is used in example 22.\n\
8939 \n\
8940 \n\
8941 \n\
8942 SYNOPSIS:\n\
8943 \n\
8944 plpath(n, x1, y1, x2, y2)\n\
8945 \n\
8946 ARGUMENTS:\n\
8947 \n\
8948  n (PLINT, input) : number of points to use to approximate the path.\n\
8949 \n\
8950  x1 (PLFLT, input) : x coordinate of first point.\n\
8951 \n\
8952  y1 (PLFLT, input) : y coordinate of first point.\n\
8953 \n\
8954  x2 (PLFLT, input) : x coordinate of second point.\n\
8955 \n\
8956  y2 (PLFLT, input) : y coordinate of second point.\n\
8957 ";
8958 static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
8959 Set up standard window and draw box\n\
8960 \n\
8961 DESCRIPTION:\n\
8962 \n\
8963  Sets up plotter environment for simple graphs by calling pladv and\n\
8964  setting up viewport and window to sensible default values. plenv\n\
8965  leaves a standard margin (left-hand margin of eight character heights,\n\
8966  and a margin around the other three sides of five character heights)\n\
8967  around most graphs for axis labels and a title. When these defaults\n\
8968  are not suitable, use the individual routines plvpas, plvpor, or\n\
8969  plvasp for setting up the viewport, plwind for defining the window,\n\
8970  and plbox for drawing the box.\n\
8971 \n\
8972  Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8973 \n\
8974  This function is used in example 1,3,9,13,14,19-22,29.\n\
8975 \n\
8976 \n\
8977 \n\
8978 SYNOPSIS:\n\
8979 \n\
8980 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8981 \n\
8982 ARGUMENTS:\n\
8983 \n\
8984  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8985  world coordinates).\n\
8986 \n\
8987  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8988  world coordinates).\n\
8989 \n\
8990  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8991  coordinates).\n\
8992 \n\
8993  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8994  coordinates).\n\
8995 \n\
8996  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8997  scales will not be set, the user must set up the scale before\n\
8998  calling plenv using plsvpa, plvasp or other.\n\
8999  0: the x and y axes are scaled independently to use as much of\n\
9000  the screen as possible.\n\
9001  1: the scales of the x and y axes are made equal.\n\
9002  2: the axis of the x and y axes are made equal, and the plot\n\
9003  box will be square.\n\
9004 \n\
9005 \n\
9006  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
9007  -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
9008  -1: draw box only.\n\
9009  0: draw box, ticks, and numeric tick labels.\n\
9010  1: also draw coordinate axes at x=0 and y=0.\n\
9011  2: also draw a grid at major tick positions in both\n\
9012  coordinates.\n\
9013  3: also draw a grid at minor tick positions in both\n\
9014  coordinates.\n\
9015  10: same as 0 except logarithmic x tick marks. (The x data\n\
9016  have to be converted to logarithms separately.)\n\
9017  11: same as 1 except logarithmic x tick marks. (The x data\n\
9018  have to be converted to logarithms separately.)\n\
9019  12: same as 2 except logarithmic x tick marks. (The x data\n\
9020  have to be converted to logarithms separately.)\n\
9021  13: same as 3 except logarithmic x tick marks. (The x data\n\
9022  have to be converted to logarithms separately.)\n\
9023  20: same as 0 except logarithmic y tick marks. (The y data\n\
9024  have to be converted to logarithms separately.)\n\
9025  21: same as 1 except logarithmic y tick marks. (The y data\n\
9026  have to be converted to logarithms separately.)\n\
9027  22: same as 2 except logarithmic y tick marks. (The y data\n\
9028  have to be converted to logarithms separately.)\n\
9029  23: same as 3 except logarithmic y tick marks. (The y data\n\
9030  have to be converted to logarithms separately.)\n\
9031  30: same as 0 except logarithmic x and y tick marks. (The x\n\
9032  and y data have to be converted to logarithms separately.)\n\
9033  31: same as 1 except logarithmic x and y tick marks. (The x\n\
9034  and y data have to be converted to logarithms separately.)\n\
9035  32: same as 2 except logarithmic x and y tick marks. (The x\n\
9036  and y data have to be converted to logarithms separately.)\n\
9037  33: same as 3 except logarithmic x and y tick marks. (The x\n\
9038  and y data have to be converted to logarithms separately.)\n\
9039  40: same as 0 except date / time x labels.\n\
9040  41: same as 1 except date / time x labels.\n\
9041  42: same as 2 except date / time x labels.\n\
9042  43: same as 3 except date / time x labels.\n\
9043  50: same as 0 except date / time y labels.\n\
9044  51: same as 1 except date / time y labels.\n\
9045  52: same as 2 except date / time y labels.\n\
9046  53: same as 3 except date / time y labels.\n\
9047  60: same as 0 except date / time x and y labels.\n\
9048  61: same as 1 except date / time x and y labels.\n\
9049  62: same as 2 except date / time x and y labels.\n\
9050  63: same as 3 except date / time x and y labels.\n\
9051  70: same as 0 except custom x and y labels.\n\
9052  71: same as 1 except custom x and y labels.\n\
9053  72: same as 2 except custom x and y labels.\n\
9054  73: same as 3 except custom x and y labels.\n\
9055 ";
9056 static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
9057 Grid data from irregularly sampled data\n\
9058 \n\
9059 DESCRIPTION:\n\
9060 \n\
9061  Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
9062  require data organized as a grid, i.e., with x sample point values\n\
9063  independent of y coordinate and vice versa. This function takes\n\
9064  irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
9065  vectors; reads the desired grid location from the input vectors\n\
9066  xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
9067  grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
9068  interpolate the data to the grid is specified with the argument type\n\
9069  which can have one parameter specified in argument data.\n\
9070 \n\
9071  Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
9072  Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
9073 \n\
9074 \n\
9075  This function is used in example 21.\n\
9076 \n\
9077 \n\
9078 \n\
9079 SYNOPSIS:\n\
9080 \n\
9081 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
9082 \n\
9083 ARGUMENTS:\n\
9084 \n\
9085  x (PLFLT_VECTOR, input) : The input x vector.\n\
9086 \n\
9087  y (PLFLT_VECTOR, input) : The input y vector.\n\
9088 \n\
9089  z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
9090  y[i], z[i] represents one data sample coordinate.\n\
9091 \n\
9092  npts (PLINT, input) : The number of data samples in the x, y and z\n\
9093  vectors.\n\
9094 \n\
9095  xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
9096  in the x direction. Usually xg has nptsx equally spaced values\n\
9097  from the minimum to the maximum values of the x input vector.\n\
9098 \n\
9099  nptsx (PLINT, input) : The number of points in the xg vector.\n\
9100 \n\
9101  yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
9102  in the y direction. Similar to the xg parameter.\n\
9103 \n\
9104  nptsy (PLINT, input) : The number of points in the yg vector.\n\
9105 \n\
9106  zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
9107  where data lies in the grid specified by xg and yg. Therefore the\n\
9108  zg matrix must be dimensioned\n\
9109  nptsx by\n\
9110  nptsy.\n\
9111 \n\
9112  type (PLINT, input) : The type of grid interpolation algorithm to\n\
9113  use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
9114  GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
9115  GRID_NNI: Natural Neighbors Interpolation\n\
9116  GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
9117  GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
9118  GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
9119  Weighted\n\
9120  For details of the algorithms read the source file plgridd.c.\n\
9121 \n\
9122  data (PLFLT, input) : Some gridding algorithms require extra data,\n\
9123  which can be specified through this argument. Currently, for\n\
9124  algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
9125  use, the lower the value, the noisier (more local) the\n\
9126  approximation is.\n\
9127  GRID_NNLI, data specifies what a thin triangle is, in the\n\
9128  range [1. .. 2.]. High values enable the usage of very thin\n\
9129  triangles for interpolation, possibly resulting in error in\n\
9130  the approximation.\n\
9131  GRID_NNI, only weights greater than data will be accepted. If\n\
9132  0, all weights will be accepted.\n\
9133 ";
9134 static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
9135 Clear current (sub)page\n\
9136 \n\
9137 DESCRIPTION:\n\
9138 \n\
9139  Clears the current page, effectively erasing everything that have been\n\
9140  drawn. This command only works with interactive drivers; if the\n\
9141  driver does not support this, the page is filled with the background\n\
9142  color in use. If the current page is divided into subpages, only the\n\
9143  current subpage is erased. The nth subpage can be selected with\n\
9144  pladv(n).\n\
9145 \n\
9146  Redacted form: General: plclear()\n\
9147 \n\
9148 \n\
9149  This function is not used in any examples.\n\
9150 \n\
9151 \n\
9152 \n\
9153 SYNOPSIS:\n\
9154 \n\
9155 plclear()\n\
9156 ";
9157 static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
9158 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
9159 \n\
9160 DESCRIPTION:\n\
9161 \n\
9162  Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
9163  and PLFLT alpha transparency value. This sets the entire color map --\n\
9164  only as many colors as specified will be allocated.\n\
9165 \n\
9166  Redacted form: plscmap0a(r, g, b, alpha)\n\
9167 \n\
9168  This function is used in examples 30.\n\
9169 \n\
9170 \n\
9171 \n\
9172 SYNOPSIS:\n\
9173 \n\
9174 plscmap0a(r, g, b, alpha, ncol0)\n\
9175 \n\
9176 ARGUMENTS:\n\
9177 \n\
9178  r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9179  integers (0-255) representing the degree of red in the color.\n\
9180 \n\
9181  g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9182  integers (0-255) representing the degree of green in the color.\n\
9183 \n\
9184  b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9185  integers (0-255) representing the degree of blue in the color.\n\
9186 \n\
9187  alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
9188  representing the alpha transparency of the color.\n\
9189 \n\
9190  ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9191  vectors.\n\
9192 ";
9193 static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
9194 Set 8-bit RGB values for given cmap0 color index\n\
9195 \n\
9196 DESCRIPTION:\n\
9197 \n\
9198  Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
9199  index. Overwrites the previous color value for the given index and,\n\
9200  thus, does not result in any additional allocation of space for\n\
9201  colors.\n\
9202 \n\
9203  Redacted form: plscol0(icol0, r, g, b)\n\
9204 \n\
9205  This function is used in any example 31.\n\
9206 \n\
9207 \n\
9208 \n\
9209 SYNOPSIS:\n\
9210 \n\
9211 plscol0(icol0, r, g, b)\n\
9212 \n\
9213 ARGUMENTS:\n\
9214 \n\
9215  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
9216  number of colors (which is set by default, by plscmap0n, or even\n\
9217  by plscmap0).\n\
9218 \n\
9219  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9220  degree of red in the color.\n\
9221 \n\
9222  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9223  degree of green in the color.\n\
9224 \n\
9225  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9226  degree of blue in the color.\n\
9227 ";
9228 static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
9229 Set up transformation from metafile coordinates\n\
9230 \n\
9231 DESCRIPTION:\n\
9232 \n\
9233  Set up transformation from metafile coordinates. The size of the plot\n\
9234  is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
9235  general-purpose facility just yet (not sure why the user would need\n\
9236  it, for one).\n\
9237 \n\
9238  Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
9239  dimypmm)\n\
9240 \n\
9241  This function is not used in any examples.\n\
9242 \n\
9243 \n\
9244 \n\
9245 SYNOPSIS:\n\
9246 \n\
9247 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
9248 \n\
9249 ARGUMENTS:\n\
9250 \n\
9251  dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
9252 \n\
9253  dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
9254 \n\
9255  dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
9256 \n\
9257  dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
9258 \n\
9259  dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9260 \n\
9261  dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9262 ";
9263 static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
9264 Creates a new stream and makes it the default\n\
9265 \n\
9266 DESCRIPTION:\n\
9267 \n\
9268  Creates a new stream and makes it the default. Differs from using\n\
9269  plsstrm, in that a free stream number is found, and returned.\n\
9270  Unfortunately, I have to start at stream 1 and work upward, since\n\
9271  stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
9272  that no initial, library-opening call is required. So stream 0 must\n\
9273  be preallocated, and there is no simple way of determining whether it\n\
9274  is already in use or not.\n\
9275 \n\
9276  Redacted form: plmkstrm(p_strm)\n\
9277 \n\
9278  This function is used in examples 1 and 20.\n\
9279 \n\
9280 \n\
9281 \n\
9282 SYNOPSIS:\n\
9283 \n\
9284 plmkstrm(p_strm)\n\
9285 \n\
9286 ARGUMENTS:\n\
9287 \n\
9288  p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
9289  number of the created stream.\n\
9290 ";
9291 static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
9292 Get page parameters\n\
9293 \n\
9294 DESCRIPTION:\n\
9295 \n\
9296  Gets the current page configuration. The length and offset values are\n\
9297  expressed in units that are specific to the current driver. For\n\
9298  instance: screen drivers will usually interpret them as number of\n\
9299  pixels, whereas printer drivers will usually use mm.\n\
9300 \n\
9301  Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9302 \n\
9303  This function is used in examples 14 and 31.\n\
9304 \n\
9305 \n\
9306 \n\
9307 SYNOPSIS:\n\
9308 \n\
9309 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9310 \n\
9311 ARGUMENTS:\n\
9312 \n\
9313  p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9314  pixels/inch (DPI) in x.\n\
9315 \n\
9316  p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9317  pixels/inch (DPI) in y.\n\
9318 \n\
9319  p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9320  length.\n\
9321 \n\
9322  p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9323  length.\n\
9324 \n\
9325  p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9326  offset.\n\
9327 \n\
9328  p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9329  offset.\n\
9330 ";
9331 static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
9332 Set format for date / time labels\n\
9333 \n\
9334 DESCRIPTION:\n\
9335 \n\
9336  Sets the format for date / time labels. To enable date / time format\n\
9337  labels see the options to plbox, plbox3, and plenv.\n\
9338 \n\
9339  Redacted form: pltimefmt(fmt)\n\
9340 \n\
9341  This function is used in example 29.\n\
9342 \n\
9343 \n\
9344 \n\
9345 SYNOPSIS:\n\
9346 \n\
9347 pltimefmt(fmt)\n\
9348 \n\
9349 ARGUMENTS:\n\
9350 \n\
9351  fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
9352  interpreted similarly to the format specifier of typical system\n\
9353  strftime routines except that PLplot ignores locale and also\n\
9354  supplies some useful extensions in the context of plotting. All\n\
9355  text in the string is printed as-is other than conversion\n\
9356  specifications which take the form of a \'%\' character followed by\n\
9357  further conversion specification character. The conversion\n\
9358  specifications which are similar to those provided by system\n\
9359  strftime routines are the following: %a: The abbreviated (English)\n\
9360  weekday name.\n\
9361  %A: The full (English) weekday name.\n\
9362  %b: The abbreviated (English) month name.\n\
9363  %B: The full (English) month name.\n\
9364  %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
9365  %C: The century number (year/100) as a 2-digit integer.\n\
9366  %d: The day of the month as a decimal number (range 01 to 31).\n\
9367  %D: Equivalent to %m/%d/%y (non-ISO).\n\
9368  %e: Like %d, but a leading zero is replaced by a space.\n\
9369  %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
9370  %h: Equivalent to %b.\n\
9371  %H: The hour as a decimal number using a 24-hour clock (range\n\
9372  00 to 23).\n\
9373  %I: The hour as a decimal number using a 12-hour clock (range\n\
9374  01 to 12).\n\
9375  %j: The day of the year as a decimal number (range 001 to\n\
9376  366).\n\
9377  %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
9378  23); single digits are preceded by a blank. (See also %H.)\n\
9379  %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
9380  12); single digits are preceded by a blank. (See also %I.)\n\
9381  %m: The month as a decimal number (range 01 to 12).\n\
9382  %M: The minute as a decimal number (range 00 to 59).\n\
9383  %n: A newline character.\n\
9384  %p: Either \"AM\" or \"PM\" according to the given time value.\n\
9385  Noon is treated as \"PM\" and midnight as \"AM\".\n\
9386  %r: Equivalent to %I:%M:%S %p.\n\
9387  %R: The time in 24-hour notation (%H:%M). For a version\n\
9388  including the seconds, see %T below.\n\
9389  %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
9390  +0000 (UTC).\n\
9391  %S: The second as a decimal number (range 00 to 60). (The\n\
9392  range is up to 60 to allow for occasional leap seconds.)\n\
9393  %t: A tab character.\n\
9394  %T: The time in 24-hour notation (%H:%M:%S).\n\
9395  %u: The day of the week as a decimal, range 1 to 7, Monday\n\
9396  being 1. See also %w.\n\
9397  %U: The week number of the current year as a decimal number,\n\
9398  range 00 to 53, starting with the first Sunday as the first\n\
9399  day of week 01. See also %V and %W.\n\
9400  %v: Equivalent to %e-%b-%Y.\n\
9401  %V: The ISO 8601 week number of the current year as a decimal\n\
9402  number, range 01 to 53, where week 1 is the first week that\n\
9403  has at least 4 days in the new year. See also %U and %W.\n\
9404  %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
9405  being 0. See also %u.\n\
9406  %W: The week number of the current year as a decimal number,\n\
9407  range 00 to 53, starting with the first Monday as the first\n\
9408  day of week 01.\n\
9409  %x: Equivalent to %a %b %d %Y.\n\
9410  %X: Equivalent to %T.\n\
9411  %y: The year as a decimal number without a century (range 00\n\
9412  to 99).\n\
9413  %Y: The year as a decimal number including a century.\n\
9414  %z: The UTC time-zone string = \"+0000\".\n\
9415  %Z: The UTC time-zone abbreviation = \"UTC\".\n\
9416  %+: The UTC date and time in default format of the Unix date\n\
9417  command which is equivalent to %a %b %d %T %Z %Y.\n\
9418  %%: A literal \"%\" character.\n\
9419  The conversion specifications which are extensions to those normally\n\
9420  provided by system strftime routines are the following: %(0-9):\n\
9421  The fractional part of the seconds field (including leading\n\
9422  decimal point) to the specified accuracy. Thus %S%3 would give\n\
9423  seconds to millisecond accuracy (00.000).\n\
9424  %.: The fractional part of the seconds field (including\n\
9425  leading decimal point) to the maximum available accuracy. Thus\n\
9426  %S%. would give seconds with fractional part up to 9 decimal\n\
9427  places if available.\n\
9428 ";
9429 static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
9430 Specify viewport using aspect ratio only\n\
9431 \n\
9432 DESCRIPTION:\n\
9433 \n\
9434  Selects the largest viewport with the given aspect ratio within the\n\
9435  subpage that leaves a standard margin (left-hand margin of eight\n\
9436  character heights, and a margin around the other three sides of five\n\
9437  character heights).\n\
9438 \n\
9439  Redacted form: plvasp(aspect)\n\
9440 \n\
9441  This function is used in example 13.\n\
9442 \n\
9443 \n\
9444 \n\
9445 SYNOPSIS:\n\
9446 \n\
9447 plvasp(aspect)\n\
9448 \n\
9449 ARGUMENTS:\n\
9450 \n\
9451  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9452  axis of resulting viewport.\n\
9453 ";
9454 static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
9455 Set output file name\n\
9456 \n\
9457 DESCRIPTION:\n\
9458 \n\
9459  Sets the current output file name, if applicable. If the file name\n\
9460  has not been specified and is required by the driver, the user will be\n\
9461  prompted for it. If using the X-windows output driver, this sets the\n\
9462  display name. This routine, if used, must be called before\n\
9463  initializing PLplot.\n\
9464 \n\
9465  Redacted form: plsfnam(fnam)\n\
9466 \n\
9467  This function is used in examples 1 and 20.\n\
9468 \n\
9469 \n\
9470 \n\
9471 SYNOPSIS:\n\
9472 \n\
9473 plsfnam(fnam)\n\
9474 \n\
9475 ARGUMENTS:\n\
9476 \n\
9477  fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9478  the file name.\n\
9479 ";
9480 static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
9481 Vector plot\n\
9482 \n\
9483 DESCRIPTION:\n\
9484 \n\
9485  Draws a plot of vector data contained in the matrices (\n\
9486  u[\n\
9487  nx][\n\
9488  ny],\n\
9489  v[\n\
9490  nx][\n\
9491  ny]) . The scaling factor for the vectors is given by scale. A\n\
9492  transformation routine pointed to by pltr with a pointer pltr_data for\n\
9493  additional data required by the transformation routine to map indices\n\
9494  within the matrices to the world coordinates. The style of the vector\n\
9495  arrow may be set using plsvect.\n\
9496 \n\
9497  Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9498  discussion) the pltr, pltr_data callback arguments are sometimes\n\
9499  replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9500  with either one or two dimensions.\n\
9501 \n\
9502  This function is used in example 22.\n\
9503 \n\
9504 \n\
9505 \n\
9506 SYNOPSIS:\n\
9507 \n\
9508 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9509 \n\
9510 ARGUMENTS:\n\
9511 \n\
9512  u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9513  and y components of the vector data to be plotted.\n\
9514 \n\
9515  nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9516 \n\
9517  scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9518  the vectors for plotting. If scale = 0 then the scaling factor is\n\
9519  automatically calculated for the data. If scale < 0 then the\n\
9520  scaling factor is automatically calculated for the data and then\n\
9521  multiplied by -\n\
9522  scale. If scale > 0 then the scaling factor is set to scale.\n\
9523 \n\
9524  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9525  defines the transformation between the zero-based indices of the\n\
9526  matrices u and v and world coordinates.For the C case,\n\
9527  transformation functions are provided in the PLplot library: pltr0\n\
9528  for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9529  mappings respectively defined by vectors and matrices. In\n\
9530  addition, C callback routines for the transformation can be\n\
9531  supplied by the user such as the mypltr function in\n\
9532  examples/c/x09c.c which provides a general linear transformation\n\
9533  between index coordinates and world coordinates.For languages\n\
9534  other than C you should consult the PLplot documentation for the\n\
9535  details concerning how PLTRANSFORM_callback arguments are\n\
9536  interfaced. However, in general, a particular pattern of\n\
9537  callback-associated arguments such as a tr vector with 6 elements;\n\
9538  xg and yg vectors; or xg and yg matrices are respectively\n\
9539  interfaced to a linear-transformation routine similar to the above\n\
9540  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9541  sophisticated bindings (see, e.g., the PLplot documentation)\n\
9542  support native language callbacks for handling index to\n\
9543  world-coordinate transformations. Examples of these various\n\
9544  approaches are given in examples/<language>x09*,\n\
9545  examples/<language>x16*, examples/<language>x20*,\n\
9546  examples/<language>x21*, and examples/<language>x22*, for all our\n\
9547  supported languages.\n\
9548 \n\
9549  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9550  information to pltr0, pltr1, pltr2, or whatever callback routine\n\
9551  that is externally supplied.\n\
9552 ";
9553 static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
9554 Set parameters that define current plot-space window\n\
9555 \n\
9556 DESCRIPTION:\n\
9557 \n\
9558  Set relative minima and maxima that define the current plot-space\n\
9559  window. If plsdiplt is not called the default values of xmin, ymin,\n\
9560  xmax, and ymax are 0., 0., 1., and 1.\n\
9561 \n\
9562  Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9563 \n\
9564  This function is used in example 31.\n\
9565 \n\
9566 \n\
9567 \n\
9568 SYNOPSIS:\n\
9569 \n\
9570 plsdiplt(xmin, ymin, xmax, ymax)\n\
9571 \n\
9572 ARGUMENTS:\n\
9573 \n\
9574  xmin (PLFLT, input) : Relative minimum in x.\n\
9575 \n\
9576  ymin (PLFLT, input) : Relative minimum in y.\n\
9577 \n\
9578  xmax (PLFLT, input) : Relative maximum in x.\n\
9579 \n\
9580  ymax (PLFLT, input) : Relative maximum in y.\n\
9581 ";
9582 static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
9583 Select line style\n\
9584 \n\
9585 DESCRIPTION:\n\
9586 \n\
9587  This sets the line style according to one of eight predefined patterns\n\
9588  (also see plstyl).\n\
9589 \n\
9590  Redacted form: pllsty(lin)\n\
9591 \n\
9592  This function is used in examples 9, 12, 22, and 25.\n\
9593 \n\
9594 \n\
9595 \n\
9596 SYNOPSIS:\n\
9597 \n\
9598 pllsty(lin)\n\
9599 \n\
9600 ARGUMENTS:\n\
9601 \n\
9602  lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9603  a continuous line, line style 2 is a line with short dashes and\n\
9604  gaps, line style 3 is a line with long dashes and gaps, line style\n\
9605  4 has long dashes and short gaps and so on.\n\
9606 ";
9607 static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
9608 Plot a glyph at the specified points\n\
9609 \n\
9610 DESCRIPTION:\n\
9611 \n\
9612  Plot a glyph at the specified points. (This function is largely\n\
9613  superseded by plstring which gives access to many[!] more glyphs.)\n\
9614 \n\
9615  Redacted form: plsym(x, y, code)\n\
9616 \n\
9617  This function is used in example 7.\n\
9618 \n\
9619 \n\
9620 \n\
9621 SYNOPSIS:\n\
9622 \n\
9623 plsym(n, x, y, code)\n\
9624 \n\
9625 ARGUMENTS:\n\
9626 \n\
9627  n (PLINT, input) : Number of points in the x and y vectors.\n\
9628 \n\
9629  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9630  the points.\n\
9631 \n\
9632  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9633  the points.\n\
9634 \n\
9635  code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9636  to be plotted at each of the n points.\n\
9637 ";
9638 static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
9639 Set the device (keyword) name\n\
9640 \n\
9641 DESCRIPTION:\n\
9642 \n\
9643  Set the device (keyword) name.\n\
9644 \n\
9645  Redacted form: plsdev(devname)\n\
9646 \n\
9647  This function is used in examples 1, 14, and 20.\n\
9648 \n\
9649 \n\
9650 \n\
9651 SYNOPSIS:\n\
9652 \n\
9653 plsdev(devname)\n\
9654 \n\
9655 ARGUMENTS:\n\
9656 \n\
9657  devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9658  containing the device name keyword of the required output device.\n\
9659  If\n\
9660  devname is NULL or if the first character of the string is a ``?\'\',\n\
9661  the normal (prompted) start up is used.\n\
9662 ";
9663 static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
9664 Set the background color by 8-bit RGB value\n\
9665 \n\
9666 DESCRIPTION:\n\
9667 \n\
9668  Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9669  the PLplot documentation).\n\
9670 \n\
9671  Redacted form: plscolbg(r, g, b)\n\
9672 \n\
9673  This function is used in examples 15 and 31.\n\
9674 \n\
9675 \n\
9676 \n\
9677 SYNOPSIS:\n\
9678 \n\
9679 plscolbg(r, g, b)\n\
9680 \n\
9681 ARGUMENTS:\n\
9682 \n\
9683  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9684  degree of red in the color.\n\
9685 \n\
9686  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9687  degree of green in the color.\n\
9688 \n\
9689  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9690  degree of blue in the color.\n\
9691 ";
9692 static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
9693 Set parameters incrementally (zoom mode) that define current plot-space window\n\
9694 \n\
9695 DESCRIPTION:\n\
9696 \n\
9697  Set relative minima and maxima incrementally (zoom mode) that define\n\
9698  the current plot-space window. This function has the same effect as\n\
9699  plsdiplt if that function has not been previously called. Otherwise,\n\
9700  this function implements zoom mode using the transformation min_used =\n\
9701  old_min + old_length*min and max_used = old_min + old_length*max for\n\
9702  each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
9703  repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9704 \n\
9705  Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9706 \n\
9707  This function is used in example 31.\n\
9708 \n\
9709 \n\
9710 \n\
9711 SYNOPSIS:\n\
9712 \n\
9713 plsdiplz(xmin, ymin, xmax, ymax)\n\
9714 \n\
9715 ARGUMENTS:\n\
9716 \n\
9717  xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9718 \n\
9719  ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9720 \n\
9721  xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9722 \n\
9723  ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9724 ";
9725 static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
9726 Advance to the next family file on the next new page\n\
9727 \n\
9728 DESCRIPTION:\n\
9729 \n\
9730  Advance to the next family file on the next new page.\n\
9731 \n\
9732  Redacted form: plfamadv()\n\
9733 \n\
9734  This function is not used in any examples.\n\
9735 \n\
9736 \n\
9737 \n\
9738 SYNOPSIS:\n\
9739 \n\
9740 plfamadv()\n\
9741 ";
9742 static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9743 Set number of colors in cmap0\n\
9744 \n\
9745 DESCRIPTION:\n\
9746 \n\
9747  Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9748  (or reallocate) cmap0, and fill with default values for those colors\n\
9749  not previously allocated. The first 16 default colors are given in\n\
9750  the plcol0 documentation. For larger indices the default color is\n\
9751  red.\n\
9752 \n\
9753  The drivers are not guaranteed to support more than 16 colors.\n\
9754 \n\
9755  Redacted form: plscmap0n(ncol0)\n\
9756 \n\
9757  This function is used in examples 15, 16, and 24.\n\
9758 \n\
9759 \n\
9760 \n\
9761 SYNOPSIS:\n\
9762 \n\
9763 plscmap0n(ncol0)\n\
9764 \n\
9765 ARGUMENTS:\n\
9766 \n\
9767  ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9768  the cmap0 palette. If this number is zero or less, then the value\n\
9769  from the previous call to plscmap0n is used and if there is no\n\
9770  previous call, then a default value is used.\n\
9771 ";
9772 static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
9773 Plot latitude and longitude lines\n\
9774 \n\
9775 DESCRIPTION:\n\
9776 \n\
9777  Displays latitude and longitude on the current plot. The lines are\n\
9778  plotted in the current color and line style.\n\
9779 \n\
9780  Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9781  minlat, maxlat)\n\
9782 \n\
9783  This function is used in example 19.\n\
9784 \n\
9785 \n\
9786 \n\
9787 SYNOPSIS:\n\
9788 \n\
9789 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9790 \n\
9791 ARGUMENTS:\n\
9792 \n\
9793  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9794  transform the coordinate longitudes and latitudes to a plot\n\
9795  coordinate system. By using this transform, we can change from a\n\
9796  longitude, latitude coordinate to a polar stereographic project,\n\
9797  for example. Initially, x[0]..[n-1] are the longitudes and\n\
9798  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9799  mapform(), x[] and y[] should be replaced by the corresponding\n\
9800  plot coordinates. If no transform is desired, mapform can be\n\
9801  replaced by NULL.\n\
9802 \n\
9803  dlong (PLFLT, input) : The interval in degrees at which the\n\
9804  longitude lines are to be plotted.\n\
9805 \n\
9806  dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9807  lines are to be plotted.\n\
9808 \n\
9809  minlong (PLFLT, input) : The value of the longitude on the left\n\
9810  side of the plot. The value of minlong must be less than the value\n\
9811  of maxlong, and the quantity maxlong-minlong must be less than or\n\
9812  equal to 360.\n\
9813 \n\
9814  maxlong (PLFLT, input) : The value of the longitude on the right\n\
9815  side of the plot.\n\
9816 \n\
9817  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9818  background. One can always use -90.0 as the boundary outside the\n\
9819  plot window will be automatically eliminated. However, the\n\
9820  program will be faster if one can reduce the size of the\n\
9821  background plotted.\n\
9822 \n\
9823  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9824  background. One can always use 90.0 as the boundary outside the\n\
9825  plot window will be automatically eliminated.\n\
9826 ";
9827 static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9828 Convert RGB color to HLS\n\
9829 \n\
9830 DESCRIPTION:\n\
9831 \n\
9832  Convert RGB color coordinates to HLS\n\
9833 \n\
9834  Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9835 \n\
9836 \n\
9837  This function is used in example 2.\n\
9838 \n\
9839 \n\
9840 \n\
9841 SYNOPSIS:\n\
9842 \n\
9843 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9844 \n\
9845 ARGUMENTS:\n\
9846 \n\
9847  r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9848 \n\
9849  g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9850 \n\
9851  b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9852 \n\
9853  p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9854  degrees (0.0-360.0) on the color cylinder.\n\
9855 \n\
9856  p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9857  expressed as a fraction (0.0-1.0) of the axis of the color\n\
9858  cylinder.\n\
9859 \n\
9860  p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9861  expressed as a fraction (0.0-1.0) of the radius of the color\n\
9862  cylinder.\n\
9863 ";
9864 static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
9865 Plot a glyph at the specified 3D points\n\
9866 \n\
9867 DESCRIPTION:\n\
9868 \n\
9869  Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9870  many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9871  this function similar to what is done for plline3. The glyph is\n\
9872  specified with a PLplot user string. Note that the user string is not\n\
9873  actually limited to one glyph so it is possible (but not normally\n\
9874  useful) to plot more than one glyph at the specified points with this\n\
9875  function. As with plmtex and plptex, the user string can contain FCI\n\
9876  escapes to determine the font, UTF-8 code to determine the glyph or\n\
9877  else PLplot escapes for Hershey or unicode text to determine the\n\
9878  glyph.\n\
9879 \n\
9880  Redacted form: plstring3(x, y, z, string)\n\
9881 \n\
9882  This function is used in example 18.\n\
9883 \n\
9884 \n\
9885 \n\
9886 SYNOPSIS:\n\
9887 \n\
9888 plstring3(n, x, y, z, string)\n\
9889 \n\
9890 ARGUMENTS:\n\
9891 \n\
9892  n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9893 \n\
9894  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9895  the points.\n\
9896 \n\
9897  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9898  the points.\n\
9899 \n\
9900  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9901  the points.\n\
9902 \n\
9903  string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9904  the glyph(s) to be plotted at each of the n points. points.\n\
9905 ";
9906 static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
9907 Switch to text screen\n\
9908 \n\
9909 DESCRIPTION:\n\
9910 \n\
9911  Sets an interactive device to text mode, used in conjunction with\n\
9912  plgra to allow graphics and text to be interspersed. On a device\n\
9913  which supports separate text and graphics windows, this command causes\n\
9914  control to be switched to the text window. This can be useful for\n\
9915  printing diagnostic messages or getting user input, which would\n\
9916  otherwise interfere with the plots. The program must switch back to\n\
9917  the graphics window before issuing plot commands, as the text (or\n\
9918  console) device will probably become quite confused otherwise. If\n\
9919  already in text mode, this command is ignored. It is also ignored on\n\
9920  devices which only support a single window or use a different method\n\
9921  for shifting focus (see also plgra).\n\
9922 \n\
9923  Redacted form: pltext()\n\
9924 \n\
9925  This function is used in example 1.\n\
9926 \n\
9927 \n\
9928 \n\
9929 SYNOPSIS:\n\
9930 \n\
9931 pltext()\n\
9932 ";
9933 static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
9934 Get parameters that define current plot-space window\n\
9935 \n\
9936 DESCRIPTION:\n\
9937 \n\
9938  Get relative minima and maxima that define current plot-space window.\n\
9939  If plsdiplt has not been called the default values pointed to by\n\
9940  p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9941 \n\
9942  Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9943 \n\
9944  This function is used in example 31.\n\
9945 \n\
9946 \n\
9947 \n\
9948 SYNOPSIS:\n\
9949 \n\
9950 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9951 \n\
9952 ARGUMENTS:\n\
9953 \n\
9954  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9955  minimum in x.\n\
9956 \n\
9957  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9958  minimum in y.\n\
9959 \n\
9960  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9961  maximum in x.\n\
9962 \n\
9963  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9964  maximum in y.\n\
9965 ";
9966 static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
9967 Get the (current) run level\n\
9968 \n\
9969 DESCRIPTION:\n\
9970 \n\
9971  Get the (current) run level. Valid settings are: 0, uninitialized\n\
9972  1, initialized\n\
9973  2, viewport defined\n\
9974  3, world coordinates defined\n\
9975 \n\
9976 \n\
9977  Redacted form: plglevel(p_level)\n\
9978 \n\
9979  This function is used in example 31.\n\
9980 \n\
9981 \n\
9982 \n\
9983 SYNOPSIS:\n\
9984 \n\
9985 plglevel(p_level)\n\
9986 \n\
9987 ARGUMENTS:\n\
9988 \n\
9989  p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9990  level.\n\
9991 ";
9992 static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
9993 Plot a histogram from binned data\n\
9994 \n\
9995 DESCRIPTION:\n\
9996 \n\
9997  Plots a histogram consisting of nbin bins. The value associated with\n\
9998  the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9999  placed in y[i]. For proper operation, the values in x[i] must form a\n\
10000  strictly increasing sequence. By default, x[i] is the left-hand edge\n\
10001  of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
10002  placed midway between the values in the x vector. Also see plhist for\n\
10003  drawing histograms from unbinned data.\n\
10004 \n\
10005  Redacted form: General: plbin(x, y, opt)\n\
10006  Python: plbin(nbin, x, y, opt)\n\
10007 \n\
10008 \n\
10009  This function is not used in any examples.\n\
10010 \n\
10011 \n\
10012 \n\
10013 SYNOPSIS:\n\
10014 \n\
10015 plbin(nbin, x, y, opt)\n\
10016 \n\
10017 ARGUMENTS:\n\
10018 \n\
10019  nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
10020  and y vectors.)\n\
10021 \n\
10022  x (PLFLT_VECTOR, input) : A vector containing values associated\n\
10023  with bins. These must form a strictly increasing sequence.\n\
10024 \n\
10025  y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
10026  proportional to the number of points in each bin. This is a PLFLT\n\
10027  (instead of PLINT) vector so as to allow histograms of\n\
10028  probabilities, etc.\n\
10029 \n\
10030  opt (PLINT, input) : Is a combination of several flags:\n\
10031  opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
10032  outer bins are expanded to fill up the entire x-axis and bins of\n\
10033  zero height are simply drawn.\n\
10034  opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
10035  between the x values. If the values in x are equally spaced,\n\
10036  the values are the center values of the bins.\n\
10037  opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
10038  size as the ones inside.\n\
10039  opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
10040  (there is a gap for such bins).\n\
10041 ";
10042 static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
10043 Plot a 2D matrix using cmap1\n\
10044 \n\
10045 DESCRIPTION:\n\
10046 \n\
10047  Plot a 2D matrix using cmap1.\n\
10048 \n\
10049  Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
10050  zmax, valuemin, valuemax, pltr, pltr_data)\n\
10051 \n\
10052 \n\
10053  This function is used in example 20.\n\
10054 \n\
10055 \n\
10056 \n\
10057 SYNOPSIS:\n\
10058 \n\
10059 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
10060 \n\
10061 ARGUMENTS:\n\
10062 \n\
10063  idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
10064  plot. Should have dimensions of\n\
10065  nx by\n\
10066  ny.\n\
10067 \n\
10068  nx, ny (PLINT, input) : Dimensions of idata\n\
10069 \n\
10070  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
10071  pltr below for how these arguments are used (only for the special case\n\
10072  when the callback function\n\
10073  pltr is not supplied).\n\
10074 \n\
10075  zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
10076  (inclusive) will be plotted.\n\
10077 \n\
10078  valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
10079  values to use for value to color mappings. A datum equal to or\n\
10080  less than valuemin will be plotted with color 0.0, while a datum\n\
10081  equal to or greater than valuemax will be plotted with color 1.0.\n\
10082  Data between valuemin and valuemax map linearly to colors in the\n\
10083  range (0.0-1.0).\n\
10084 \n\
10085  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
10086  defines the transformation between the zero-based indices of the\n\
10087  matrix idata and world coordinates. If\n\
10088  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
10089  indices of idata are mapped to the range\n\
10090  xmin through\n\
10091  xmax and the y indices of idata are mapped to the range\n\
10092  ymin through\n\
10093  ymax.For the C case, transformation functions are provided in the\n\
10094  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
10095  pltr2 for arbitrary mappings respectively defined by vectors and\n\
10096  matrices. In addition, C callback routines for the transformation\n\
10097  can be supplied by the user such as the mypltr function in\n\
10098  examples/c/x09c.c which provides a general linear transformation\n\
10099  between index coordinates and world coordinates.For languages\n\
10100  other than C you should consult the PLplot documentation for the\n\
10101  details concerning how PLTRANSFORM_callback arguments are\n\
10102  interfaced. However, in general, a particular pattern of\n\
10103  callback-associated arguments such as a tr vector with 6 elements;\n\
10104  xg and yg vectors; or xg and yg matrices are respectively\n\
10105  interfaced to a linear-transformation routine similar to the above\n\
10106  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
10107  sophisticated bindings (see, e.g., the PLplot documentation)\n\
10108  support native language callbacks for handling index to\n\
10109  world-coordinate transformations. Examples of these various\n\
10110  approaches are given in examples/<language>x09*,\n\
10111  examples/<language>x16*, examples/<language>x20*,\n\
10112  examples/<language>x21*, and examples/<language>x22*, for all our\n\
10113  supported languages.\n\
10114 \n\
10115  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10116  information to pltr0, pltr1, pltr2, or whatever routine is\n\
10117  externally supplied.\n\
10118 ";
10119 static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
10120 Get family, style and weight of the current font\n\
10121 \n\
10122 DESCRIPTION:\n\
10123 \n\
10124  Gets information about current font. See the PLplot documentation for\n\
10125  more information on font selection.\n\
10126 \n\
10127  Redacted form: plgfont(p_family, p_style, p_weight)\n\
10128 \n\
10129  This function is used in example 23.\n\
10130 \n\
10131 \n\
10132 \n\
10133 SYNOPSIS:\n\
10134 \n\
10135 plgfont(p_family, p_style, p_weight)\n\
10136 \n\
10137 ARGUMENTS:\n\
10138 \n\
10139  p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10140  font family. The available values are given by the PL_FCI_*\n\
10141  constants in plplot.h. Current options are PL_FCI_SANS,\n\
10142  PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
10143  p_family is NULL then the font family is not returned.\n\
10144 \n\
10145  p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10146  font style. The available values are given by the PL_FCI_*\n\
10147  constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
10148  PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
10149  style is not returned.\n\
10150 \n\
10151  p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10152  font weight. The available values are given by the PL_FCI_*\n\
10153  constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
10154  PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
10155  returned.\n\
10156 ";
10157 static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
10158 Get z axis parameters\n\
10159 \n\
10160 DESCRIPTION:\n\
10161 \n\
10162  Identical to plgxax, except that arguments are flags for z axis. See\n\
10163  the description of plgxax for more detail.\n\
10164 \n\
10165  Redacted form: plgzax(p_digmax, p_digits)\n\
10166 \n\
10167  This function is used in example 31.\n\
10168 \n\
10169 \n\
10170 \n\
10171 SYNOPSIS:\n\
10172 \n\
10173 plgzax(p_digmax, p_digits)\n\
10174 \n\
10175 ARGUMENTS:\n\
10176 \n\
10177  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
10178  number of digits for the z axis. If nonzero, the printed label\n\
10179  has been switched to a floating-point representation when the\n\
10180  number of digits exceeds this value.\n\
10181 \n\
10182  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
10183  number of digits for the numeric labels (z axis) from the last\n\
10184  plot.\n\
10185 ";
10186 static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
10187 Write text inside the viewport of a 3D plot\n\
10188 \n\
10189 DESCRIPTION:\n\
10190 \n\
10191  Writes text at a specified position and inclination and with a\n\
10192  specified shear within the viewport. Text is clipped at the viewport\n\
10193  boundaries. The reference point of a string lies along a line passing\n\
10194  through the string at half the height of a capital letter. The\n\
10195  position of the reference point along this line is determined by just,\n\
10196  and the reference point is placed at world coordinates (\n\
10197  wx,\n\
10198  wy,\n\
10199  wz) within the viewport. The inclination and shear of the string is\n\
10200  specified in terms of differences of world coordinates making it easy\n\
10201  to write text parallel to a line in a graph.\n\
10202 \n\
10203  Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
10204 \n\
10205  This function is used in example 28.\n\
10206 \n\
10207 \n\
10208 \n\
10209 SYNOPSIS:\n\
10210 \n\
10211 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
10212 \n\
10213 ARGUMENTS:\n\
10214 \n\
10215  wx (PLFLT, input) : x world coordinate of reference point of\n\
10216  string.\n\
10217 \n\
10218  wy (PLFLT, input) : y world coordinate of reference point of\n\
10219  string.\n\
10220 \n\
10221  wz (PLFLT, input) : z world coordinate of reference point of\n\
10222  string.\n\
10223 \n\
10224  dx (PLFLT, input) : Together with dy and\n\
10225  dz , this specifies the inclination of the string. The baseline of\n\
10226  the string is parallel to a line joining (\n\
10227  x,\n\
10228  y,\n\
10229  z) to (\n\
10230  x+\n\
10231  dx,\n\
10232  y+\n\
10233  dy,\n\
10234  z+\n\
10235  dz) .\n\
10236 \n\
10237  dy (PLFLT, input) : Together with dx and\n\
10238  dz, this specifies the inclination of the string.\n\
10239 \n\
10240  dz (PLFLT, input) : Together with dx and\n\
10241  dy, this specifies the inclination of the string.\n\
10242 \n\
10243  sx (PLFLT, input) : Together with sy and\n\
10244  sz , this specifies the shear of the string. The string is sheared so\n\
10245  that the characters are vertically parallel to a line joining (\n\
10246  x,\n\
10247  y,\n\
10248  z) to (\n\
10249  x+\n\
10250  sx,\n\
10251  y+\n\
10252  sy,\n\
10253  z+\n\
10254  sz) . If sx =\n\
10255  sy =\n\
10256  sz = 0.) then the text is not sheared.\n\
10257 \n\
10258  sy (PLFLT, input) : Together with sx and\n\
10259  sz, this specifies shear of the string.\n\
10260 \n\
10261  sz (PLFLT, input) : Together with sx and\n\
10262  sy, this specifies shear of the string.\n\
10263 \n\
10264  just (PLFLT, input) : Specifies the position of the string relative\n\
10265  to its reference point. If just=0. , the reference point is at\n\
10266  the left and if just=1. , it is at the right of the string. Other\n\
10267  values of just give intermediate justifications.\n\
10268 \n\
10269  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
10270  written out.\n\
10271 ";
10272 static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
10273 Draw a box with axes, etc. with arbitrary origin\n\
10274 \n\
10275 DESCRIPTION:\n\
10276 \n\
10277  Draws a box around the currently defined viewport with arbitrary\n\
10278  world-coordinate origin specified by x0 and y0 and labels it with\n\
10279  world coordinate values appropriate to the window. Thus plaxes should\n\
10280  only be called after defining both viewport and window. The ascii\n\
10281  character strings xopt and yopt specify how the box should be drawn as\n\
10282  described below. If ticks and/or subticks are to be drawn for a\n\
10283  particular axis, the tick intervals and number of subintervals may be\n\
10284  specified explicitly, or they may be defaulted by setting the\n\
10285  appropriate arguments to zero.\n\
10286 \n\
10287  Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
10288  ytick, nysub)\n\
10289 \n\
10290 \n\
10291  This function is not used in any examples.\n\
10292 \n\
10293 \n\
10294 \n\
10295 SYNOPSIS:\n\
10296 \n\
10297 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
10298 \n\
10299 ARGUMENTS:\n\
10300 \n\
10301  x0 (PLFLT, input) : World X coordinate of origin.\n\
10302 \n\
10303  y0 (PLFLT, input) : World Y coordinate of origin.\n\
10304 \n\
10305  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10306  options for the x axis. The string can include any combination of\n\
10307  the following letters (upper or lower case) in any order: a: Draws\n\
10308  axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
10309  (x=0).\n\
10310  b: Draws bottom (X) or left (Y) edge of frame.\n\
10311  c: Draws top (X) or right (Y) edge of frame.\n\
10312  d: Plot labels as date / time. Values are assumed to be\n\
10313  seconds since the epoch (as used by gmtime).\n\
10314  f: Always use fixed point numeric labels.\n\
10315  g: Draws a grid at the major tick interval.\n\
10316  h: Draws a grid at the minor tick interval.\n\
10317  i: Inverts tick marks, so they are drawn outwards, rather than\n\
10318  inwards.\n\
10319  l: Labels axis logarithmically. This only affects the labels,\n\
10320  not the data, and so it is necessary to compute the logarithms\n\
10321  of data points before passing them to any of the drawing\n\
10322  routines.\n\
10323  m: Writes numeric labels at major tick intervals in the\n\
10324  unconventional location (above box for X, right of box for Y).\n\
10325  n: Writes numeric labels at major tick intervals in the\n\
10326  conventional location (below box for X, left of box for Y).\n\
10327  o: Use custom labelling function to generate axis label text.\n\
10328  The custom labelling function can be defined with the\n\
10329  plslabelfunc command.\n\
10330  s: Enables subticks between major ticks, only valid if t is\n\
10331  also specified.\n\
10332  t: Draws major ticks.\n\
10333  u: Exactly like \"b\" except don\'t draw edge line.\n\
10334  w: Exactly like \"c\" except don\'t draw edge line.\n\
10335  x: Exactly like \"t\" (including the side effect of the\n\
10336  numerical labels for the major ticks) except exclude drawing\n\
10337  the major and minor tick marks.\n\
10338 \n\
10339 \n\
10340  xtick (PLFLT, input) : World coordinate interval between major\n\
10341  ticks on the x axis. If it is set to zero, PLplot automatically\n\
10342  generates a suitable tick interval.\n\
10343 \n\
10344  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
10345  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10346  generates a suitable minor tick interval.\n\
10347 \n\
10348  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10349  options for the y axis. The string can include any combination of\n\
10350  the letters defined above for xopt, and in addition may contain:\n\
10351  v: Write numeric labels for the y axis parallel to the base of the\n\
10352  graph, rather than parallel to the axis.\n\
10353 \n\
10354 \n\
10355  ytick (PLFLT, input) : World coordinate interval between major\n\
10356  ticks on the y axis. If it is set to zero, PLplot automatically\n\
10357  generates a suitable tick interval.\n\
10358 \n\
10359  nysub (PLINT, input) : Number of subintervals between major y axis\n\
10360  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10361  generates a suitable minor tick interval.\n\
10362 ";
10363 static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
10364 Returns the background color (cmap0[0]) by 8-bit RGB value\n\
10365 \n\
10366 DESCRIPTION:\n\
10367 \n\
10368  Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
10369 \n\
10370  Redacted form: plgcolbg(r, g, b)\n\
10371 \n\
10372  This function is used in example 31.\n\
10373 \n\
10374 \n\
10375 \n\
10376 SYNOPSIS:\n\
10377 \n\
10378 plgcolbg(r, g, b)\n\
10379 \n\
10380 ARGUMENTS:\n\
10381 \n\
10382  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10383  in the range from 0 to 255.\n\
10384 \n\
10385  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10386  in the range from 0 to 255.\n\
10387 \n\
10388  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10389  in the range from 0 to 255.\n\
10390 ";
10391 static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
10392 Plot a glyph at the specified 3D points\n\
10393 \n\
10394 DESCRIPTION:\n\
10395 \n\
10396  Plot a glyph at the specified 3D points. (This function is largely\n\
10397  superseded by plstring3 which gives access to many[!] more glyphs.)\n\
10398  Set up the call to this function similar to what is done for plline3.\n\
10399  code=-1 means try to just draw a point. Right now it\'s just a move\n\
10400  and a draw at the same place. Not ideal, since a sufficiently\n\
10401  intelligent output device may optimize it away, or there may be faster\n\
10402  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
10403  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
10404  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
10405  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
10406  code <= 127 the corresponding printable ASCII character is plotted.\n\
10407 \n\
10408  Redacted form: plpoin3(x, y, z, code)\n\
10409 \n\
10410  This function is not used in any example.\n\
10411 \n\
10412 \n\
10413 \n\
10414 SYNOPSIS:\n\
10415 \n\
10416 plpoin3(n, x, y, z, code)\n\
10417 \n\
10418 ARGUMENTS:\n\
10419 \n\
10420  n (PLINT, input) : Number of points in the x and y vectors.\n\
10421 \n\
10422  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10423  points.\n\
10424 \n\
10425  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10426  points.\n\
10427 \n\
10428  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10429  points.\n\
10430 \n\
10431  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10432  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10433  each of the n points.\n\
10434 ";
10435 static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10436 Draw a polygon in 3 space\n\
10437 \n\
10438 DESCRIPTION:\n\
10439 \n\
10440  Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10441  like plline3, but differs from that function in that plpoly3 attempts\n\
10442  to determine if the polygon is viewable depending on the order of the\n\
10443  points within the vector and the value of ifcc. If the back of\n\
10444  polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10445  you want, then use plline3 instead.\n\
10446 \n\
10447  The points are assumed to be in a plane, and the directionality of the\n\
10448  plane is determined from the first three points. Additional points do\n\
10449  not have to lie on the plane defined by the first three, but if they\n\
10450  do not, then the determination of visibility obviously can\'t be 100%\n\
10451  accurate... So if you\'re 3 space polygons are too far from planar,\n\
10452  consider breaking them into smaller polygons. 3 points define a plane\n\
10453  :-).\n\
10454 \n\
10455  Bugs: If one of the first two segments is of zero length, or if they\n\
10456  are co-linear, the calculation of visibility has a 50/50 chance of\n\
10457  being correct. Avoid such situations :-). See x18c.c for an example\n\
10458  of this problem. (Search for 20.1).\n\
10459 \n\
10460  Redacted form: plpoly3(x, y, z, code)\n\
10461 \n\
10462  This function is used in example 18.\n\
10463 \n\
10464 \n\
10465 \n\
10466 SYNOPSIS:\n\
10467 \n\
10468 plpoly3(n, x, y, z, draw, ifcc)\n\
10469 \n\
10470 ARGUMENTS:\n\
10471 \n\
10472  n (PLINT, input) : Number of points defining line.\n\
10473 \n\
10474  x (PLFLT_VECTOR, input) : A vector containing\n\
10475  n x coordinates of points.\n\
10476 \n\
10477  y (PLFLT_VECTOR, input) : A vector containing\n\
10478  n y coordinates of points.\n\
10479 \n\
10480  z (PLFLT_VECTOR, input) : A vector containing\n\
10481  n z coordinates of points.\n\
10482 \n\
10483  draw (PLBOOL_VECTOR, input) : A vector containing\n\
10484  n-1 Boolean values which control drawing the segments of the polygon.\n\
10485  If draw[i] is true, then the polygon segment from index [i] to\n\
10486  [i+1] is drawn, otherwise, not.\n\
10487 \n\
10488  ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10489  polygon is determined by assuming the points are laid out in a\n\
10490  counter-clockwise order. Otherwise, the directionality of the\n\
10491  polygon is determined by assuming the points are laid out in a\n\
10492  clockwise order.\n\
10493 ";
10494 static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
10495 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10496 \n\
10497 DESCRIPTION:\n\
10498 \n\
10499  Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10500  PLFLT alpha transparency value (see the PLplot documentation).\n\
10501 \n\
10502  This function is used in example 31.\n\
10503 \n\
10504 \n\
10505 \n\
10506 SYNOPSIS:\n\
10507 \n\
10508 plscolbga(r, g, b, alpha)\n\
10509 \n\
10510 ARGUMENTS:\n\
10511 \n\
10512  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10513  degree of red in the color.\n\
10514 \n\
10515  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10516  degree of green in the color.\n\
10517 \n\
10518  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10519  degree of blue in the color.\n\
10520 \n\
10521  alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10522  (0.0-1.0).\n\
10523 ";
10524 static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
10525 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10526 \n\
10527 DESCRIPTION:\n\
10528 \n\
10529  Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10530  alpha transparency value.\n\
10531 \n\
10532  This function is used in example 31.\n\
10533 \n\
10534 \n\
10535 \n\
10536 SYNOPSIS:\n\
10537 \n\
10538 plgcolbga(r, g, b, alpha)\n\
10539 \n\
10540 ARGUMENTS:\n\
10541 \n\
10542  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10543  in the range from 0 to 255.\n\
10544 \n\
10545  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10546  in the range from 0 to 255.\n\
10547 \n\
10548  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10549  in the range from 0 to 255.\n\
10550 \n\
10551  alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10552  transparency in the range (0.0-1.0).\n\
10553 ";
10554 static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
10555 Draw error bars in x direction\n\
10556 \n\
10557 DESCRIPTION:\n\
10558 \n\
10559  Draws a set of n error bars in x direction, the i\'th error bar\n\
10560  extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10561  of the error bars are of length equal to the minor tick length\n\
10562  (settable using plsmin).\n\
10563 \n\
10564  Redacted form: General: plerrx(xmin, ymax, y)\n\
10565 \n\
10566 \n\
10567  This function is used in example 29.\n\
10568 \n\
10569 \n\
10570 \n\
10571 SYNOPSIS:\n\
10572 \n\
10573 plerrx(n, xmin, xmax, y)\n\
10574 \n\
10575 ARGUMENTS:\n\
10576 \n\
10577  n (PLINT, input) : Number of error bars to draw.\n\
10578 \n\
10579  xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10580  of the left-hand endpoints of the error bars.\n\
10581 \n\
10582  xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10583  of the right-hand endpoints of the error bars.\n\
10584 \n\
10585  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10586  the error bars.\n\
10587 ";
10588 static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
10589 Eject current page\n\
10590 \n\
10591 DESCRIPTION:\n\
10592 \n\
10593  Clears the graphics screen of an interactive device, or ejects a page\n\
10594  on a plotter. See plbop for more information.\n\
10595 \n\
10596  Redacted form: pleop()\n\
10597 \n\
10598  This function is used in example 2,14.\n\
10599 \n\
10600 \n\
10601 \n\
10602 SYNOPSIS:\n\
10603 \n\
10604 pleop()\n\
10605 ";
10606 static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
10607 Convert HLS color to RGB\n\
10608 \n\
10609 DESCRIPTION:\n\
10610 \n\
10611  Convert HLS color coordinates to RGB.\n\
10612 \n\
10613  Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10614 \n\
10615 \n\
10616  This function is used in example 2.\n\
10617 \n\
10618 \n\
10619 \n\
10620 SYNOPSIS:\n\
10621 \n\
10622 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10623 \n\
10624 ARGUMENTS:\n\
10625 \n\
10626  h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10627  cylinder.\n\
10628 \n\
10629  l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10630  the axis of the color cylinder.\n\
10631 \n\
10632  s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10633  the radius of the color cylinder.\n\
10634 \n\
10635  p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10636  (0.0-1.0) of the color.\n\
10637 \n\
10638  p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10639  intensity (0.0-1.0) of the color.\n\
10640 \n\
10641  p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10642  intensity (0.0-1.0) of the color.\n\
10643 ";
10644 static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
10645 Plot all or a subset of Shapefile data, filling the polygons\n\
10646 \n\
10647 DESCRIPTION:\n\
10648 \n\
10649  As per plmapline, however the items are filled in the same way as\n\
10650  plfill.\n\
10651 \n\
10652  Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10653  plotentries)\n\
10654 \n\
10655  This function is used in example 19.\n\
10656 \n\
10657 \n\
10658 \n\
10659 SYNOPSIS:\n\
10660 \n\
10661 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10662 \n\
10663 ARGUMENTS:\n\
10664 \n\
10665  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10666  transform the coordinates given in the shapefile into a plot\n\
10667  coordinate system. By using this transform, we can change from a\n\
10668  longitude, latitude coordinate to a polar stereographic project,\n\
10669  for example. Initially, x[0]..[n-1] are the longitudes and\n\
10670  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10671  mapform(), x[] and y[] should be replaced by the corresponding\n\
10672  plot coordinates. If no transform is desired, mapform can be\n\
10673  replaced by NULL.\n\
10674 \n\
10675  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10676  the file name of a set of Shapefile files without the file\n\
10677  extension.\n\
10678 \n\
10679  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10680  be in the same units as used by the Shapefile. You could use a\n\
10681  very large negative number to plot everything, but you can improve\n\
10682  performance by limiting the area drawn. The units must match those\n\
10683  of the Shapefile projection, which may be for example longitude or\n\
10684  distance. The value of minx must be less than the value of maxx.\n\
10685 \n\
10686  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10687  use a very large number to plot everything, but you can improve\n\
10688  performance by limiting the area drawn.\n\
10689 \n\
10690  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10691  be in the same units as used by the Shapefile. You could use a\n\
10692  very large negative number to plot everything, but you can improve\n\
10693  performance by limiting the area drawn. The units must match those\n\
10694  of the Shapefile projection, which may be for example latitude or\n\
10695  distance. The value of miny must be less than the value of maxy.\n\
10696 \n\
10697  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10698  use a very large number to plot everything, but you can improve\n\
10699  performance by limiting the area drawn.\n\
10700 \n\
10701  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10702  zero-based indices of the Shapefile elements which will be drawn.\n\
10703  Setting\n\
10704  plotentries to NULL will plot all elements of the Shapefile.\n\
10705 \n\
10706  nplotentries (PLINT, input) : The number of items in\n\
10707  plotentries. Ignored if\n\
10708  plotentries is NULL.\n\
10709 ";
10710 static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
10711 Draw error bars in the y direction\n\
10712 \n\
10713 DESCRIPTION:\n\
10714 \n\
10715  Draws a set of n error bars in the y direction, the i\'th error bar\n\
10716  extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10717  of the error bars are of length equal to the minor tick length\n\
10718  (settable using plsmin).\n\
10719 \n\
10720  Redacted form: General: plerry(x, ymin, ymax)\n\
10721 \n\
10722 \n\
10723  This function is used in example 29.\n\
10724 \n\
10725 \n\
10726 \n\
10727 SYNOPSIS:\n\
10728 \n\
10729 plerry(n, x, ymin, ymax)\n\
10730 \n\
10731 ARGUMENTS:\n\
10732 \n\
10733  n (PLINT, input) : Number of error bars to draw.\n\
10734 \n\
10735  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10736  the error bars.\n\
10737 \n\
10738  ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10739  of the lower endpoints of the error bars.\n\
10740 \n\
10741  ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10742  of the upper endpoints of the error bars.\n\
10743 ";
10744 static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
10745 Set FCI (font characterization integer)\n\
10746 \n\
10747 DESCRIPTION:\n\
10748 \n\
10749  Sets font characteristics to be used at the start of the next string\n\
10750  using the FCI approach. See the PLplot documentation for more\n\
10751  information. Note, plsfont (which calls plsfci internally) provides a\n\
10752  more user-friendly API for setting the font characterisitics.\n\
10753 \n\
10754  Redacted form: General: plsfci(fci)\n\
10755 \n\
10756 \n\
10757  This function is used in example 23.\n\
10758 \n\
10759 \n\
10760 \n\
10761 SYNOPSIS:\n\
10762 \n\
10763 plsfci(fci)\n\
10764 \n\
10765 ARGUMENTS:\n\
10766 \n\
10767  fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10768  of FCI.\n\
10769 ";
10770 static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
10771 Select area fill pattern\n\
10772 \n\
10773 DESCRIPTION:\n\
10774 \n\
10775  If\n\
10776  patt is zero or less use either a hardware solid fill if the drivers\n\
10777  have that capability (virtually all do) or fall back to a software\n\
10778  emulation of a solid fill using the eighth area line fill pattern. If\n\
10779  0 <\n\
10780  patt <= 8, then select one of eight predefined area line fill patterns\n\
10781  to use (see plpat if you desire other patterns).\n\
10782 \n\
10783  Redacted form: plpsty(patt)\n\
10784 \n\
10785  This function is used in examples 12, 13, 15, 16, and 25.\n\
10786 \n\
10787 \n\
10788 \n\
10789 SYNOPSIS:\n\
10790 \n\
10791 plpsty(patt)\n\
10792 \n\
10793 ARGUMENTS:\n\
10794 \n\
10795  patt (PLINT, input) : The desired pattern index. If\n\
10796  patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10797  above) used. For\n\
10798  patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10799  line fill capability itself (most deliberately do not so that line\n\
10800  fill patterns look identical for those drivers), the patterns\n\
10801  consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10802  45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10803  lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10804  (8) lines at both 45 degrees and -45 degrees.\n\
10805 ";
10806 static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
10807 Set symbol size\n\
10808 \n\
10809 DESCRIPTION:\n\
10810 \n\
10811  This sets up the size of all subsequent symbols drawn by plpoin and\n\
10812  plsym. The actual height of a symbol is the product of the default\n\
10813  symbol size and a scaling factor as for the character height.\n\
10814 \n\
10815  Redacted form: plssym(def, scale)\n\
10816 \n\
10817  This function is used in example 29.\n\
10818 \n\
10819 \n\
10820 \n\
10821 SYNOPSIS:\n\
10822 \n\
10823 plssym(def, scale)\n\
10824 \n\
10825 ARGUMENTS:\n\
10826 \n\
10827  def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10828  should be set to zero if the default height is to remain\n\
10829  unchanged.\n\
10830 \n\
10831  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10832  actual symbol height.\n\
10833 ";
10834 static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
10835 Initialization\n\
10836 \n\
10837 DESCRIPTION:\n\
10838 \n\
10839  Alternative to plstar for initializing the plotting package. The\n\
10840  device name keyword for the desired output device must be supplied as\n\
10841  an argument. These keywords are the same as those printed out by\n\
10842  plstar. If the requested device is not available, or if the input\n\
10843  string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10844  is used. This routine also divides the output device page into nx by\n\
10845  ny subpages, each of which may be used independently. The subroutine\n\
10846  pladv is used to advance from one subpage to the next.\n\
10847 \n\
10848  Redacted form: General: plstart(devname, nx, ny)\n\
10849 \n\
10850 \n\
10851  This function is not used in any examples.\n\
10852 \n\
10853 \n\
10854 \n\
10855 SYNOPSIS:\n\
10856 \n\
10857 plstart(devname, nx, ny)\n\
10858 \n\
10859 ARGUMENTS:\n\
10860 \n\
10861  devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10862  containing the device name keyword of the required output device.\n\
10863  If\n\
10864  devname is NULL or if the first character of the string is a ``?\'\',\n\
10865  the normal (prompted) start up is used.\n\
10866 \n\
10867  nx (PLINT, input) : Number of subpages to divide output page in the\n\
10868  x direction.\n\
10869 \n\
10870  ny (PLINT, input) : Number of subpages to divide output page in the\n\
10871  y direction.\n\
10872 ";
10873 
10874 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10875  PLINT arg1 ;
10876  PLINT *arg2 = (PLINT *) 0 ;
10877  char **arg3 = (char **) 0 ;
10878  Matrix temp1 ;
10879  octave_value_list _out;
10880  octave_value_list *_outp=&_out;
10881  octave_value _outv;
10882 
10883  try {
10884  if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10885  SWIG_fail;
10886  }
10887  {
10888  if ( _n_dims( args(0) ) > 1 )
10889  {
10890  error( "argument must be a scalar or vector" ); SWIG_fail;
10891  }
10892  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10893  arg2 = new PLINT[Alen];
10894  temp1 = args(0).matrix_value();
10895  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10896  }
10897  {
10898  charMatrix temp_matrix;
10899  Cell temp_cell;
10900  char *tmp_cstring;
10901  std::string str;
10902  size_t max_length = 0, non_blank_length;
10903  int i, ifcell;
10904  if ( _n_dims( args(1) ) > 2 )
10905  {
10906  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10907  }
10908 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10909  if ( !args(1).isempty() )
10910 #else
10911  if ( !args(1).is_empty() )
10912 #endif
10913  {
10914  if ( _dim( args(1), 0 ) != Alen )
10915  {
10916  error( "first dimension must be same length as previous vector" ); SWIG_fail;
10917  }
10918  arg3 = new char*[Alen];
10919 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10920  ifcell = args(1).iscell();
10921 #else
10922  ifcell = args(1).is_cell();
10923 #endif
10924  if ( ifcell )
10925  {
10926  temp_cell = args(1).cell_value();
10927  }
10928  else
10929  {
10930  temp_matrix = args(1).char_matrix_value();
10931  // Allow one extra space for null termination.
10932  max_length = _dim( args(1), 1 ) + 1;
10933  }
10934 
10935  for ( i = 0; i < Alen; i++ )
10936  {
10937  // Must copy string to "permanent" location because the string
10938  // location corresponding to tmp_cstring gets
10939  // overwritten for each iteration of loop.
10940  if ( ifcell )
10941  {
10942  if ( temp_cell.elem( i ).is_string() )
10943  {
10944  str = temp_cell.elem( i ).string_value();
10945  // leave room for null termination.
10946  max_length = str.size() + 1;
10947  tmp_cstring = (char *) str.c_str();
10948  }
10949  else
10950  {
10951  // Use null string if user attempts to pass a cell array
10952  // with a non-string element (likely an empty element
10953  // since that should be allowed by the PLplot interface
10954  // if that element is going to be unused).
10955  // leave room for null termination.
10956  max_length = 1;
10957  tmp_cstring = (char *) "";
10958  }
10959  }
10960  else
10961  {
10962  str = temp_matrix.row_as_string( i );
10963  tmp_cstring = (char *) str.c_str();
10964  }
10965  arg3[i] = new char[max_length];
10966  strncpy( arg3[i], tmp_cstring, max_length - 1 );
10967  arg3[i][max_length - 1] = '\0';
10968  // All the trailing blank crapola should not be needed for
10969  // string cell arrays.
10970  if ( !ifcell )
10971  {
10972  // remove trailing-blank padding that is used by the
10973  // charMatrix class to insure all strings in a given
10974  // charMatrix instance have the same length.
10975  // This transformation also removes legitimate trailing
10976  // blanks but there is nothing we can do about that
10977  // for the charMatrix class.
10978 
10979  // Look for trailing nulls first (just in case, although that
10980  // shouldn't happen if charMatrix implemented as documented)
10981  // before looking for trailing blanks.
10982  non_blank_length = max_length - 2;
10983  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
10984  {
10985  non_blank_length--;
10986  }
10987  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
10988  {
10989  non_blank_length--;
10990  }
10991  arg3[i][non_blank_length + 1] = '\0';
10992  }
10993  }
10994  }
10995  else
10996  {
10997  arg3 = NULL;
10998  }
10999  }
11000  testppchar(arg1,(int const *)arg2,(char const **)arg3);
11001  _outv = octave_value();
11002  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11003  {
11004  delete [] arg2;
11005  }
11006  {
11007  int i;
11008  if ( arg3 != NULL )
11009  {
11010  for ( i = 0; i < Alen; i++ )
11011  {
11012  delete[] arg3[i];
11013  }
11014  delete[] arg3;
11015  }
11016  }
11017  return _out;
11018  fail:
11019  {
11020  delete [] arg2;
11021  }
11022  {
11023  int i;
11024  if ( arg3 != NULL )
11025  {
11026  for ( i = 0; i < Alen; i++ )
11027  {
11028  delete[] arg3[i];
11029  }
11030  delete[] arg3;
11031  }
11032  }
11033  return octave_value_list();
11034  }
11035  catch(...) {
11036  {
11037  delete [] arg2;
11038  }
11039  {
11040  int i;
11041  if ( arg3 != NULL )
11042  {
11043  for ( i = 0; i < Alen; i++ )
11044  {
11045  delete[] arg3[i];
11046  }
11047  delete[] arg3;
11048  }
11049  }
11050  throw;
11051  }
11052 }
11053 
11054 
11056  int *arg1 = (int *) 0 ;
11057  int *arg2 = (int *) 0 ;
11058  int *arg3 = (int *) 0 ;
11059  char *arg4 = (char *) 0 ;
11060  int *arg5 = (int *) 0 ;
11061  int *arg6 = (int *) 0 ;
11062  PLFLT *arg7 = (PLFLT *) 0 ;
11063  PLFLT *arg8 = (PLFLT *) 0 ;
11064  PLFLT *arg9 = (PLFLT *) 0 ;
11065  PLFLT *arg10 = (PLFLT *) 0 ;
11066  int *arg11 = (int *) 0 ;
11067  int temp1 ;
11068  int res1 = SWIG_TMPOBJ ;
11069  int temp2 ;
11070  int res2 = SWIG_TMPOBJ ;
11071  int temp3 ;
11072  int res3 = SWIG_TMPOBJ ;
11073  char local_string4[80] ;
11074  int temp5 ;
11075  int res5 = SWIG_TMPOBJ ;
11076  int temp6 ;
11077  int res6 = SWIG_TMPOBJ ;
11078  PLFLT temp7 ;
11079  int res7 = SWIG_TMPOBJ ;
11080  PLFLT temp8 ;
11081  int res8 = SWIG_TMPOBJ ;
11082  PLFLT temp9 ;
11083  int res9 = SWIG_TMPOBJ ;
11084  PLFLT temp10 ;
11085  int res10 = SWIG_TMPOBJ ;
11086  int temp11 ;
11087  int res11 = SWIG_TMPOBJ ;
11088  size_t local_string_length4 ;
11089  charMatrix local_charMatrix4 ;
11090  octave_value_list retval4 ;
11091  octave_value_list _out;
11092  octave_value_list *_outp=&_out;
11093  octave_value _outv;
11094  int result;
11095 
11096  try {
11097  arg1 = &temp1;
11098  arg2 = &temp2;
11099  arg3 = &temp3;
11100  {
11101  arg4 = local_string4;
11102  }
11103  arg5 = &temp5;
11104  arg6 = &temp6;
11105  arg7 = &temp7;
11106  arg8 = &temp8;
11107  arg9 = &temp9;
11108  arg10 = &temp10;
11109  arg11 = &temp11;
11110  if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
11111  SWIG_fail;
11112  }
11113  result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11114  _outv = SWIG_From_int(static_cast< int >(result));
11115  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11116  if (SWIG_IsTmpObj(res1)) {
11117  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11118  } else {
11119  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11120  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11121  }
11122  if (SWIG_IsTmpObj(res2)) {
11123  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
11124  } else {
11125  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11126  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
11127  }
11128  if (SWIG_IsTmpObj(res3)) {
11129  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
11130  } else {
11131  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11132  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11133  }
11134  {
11135  local_string_length4 = strlen( local_string4 );
11136  local_charMatrix4 = charMatrix( 1, local_string_length4 );
11137  local_charMatrix4.insert( local_string4, 0, 0 );
11138  retval4( 0 ) = octave_value( local_charMatrix4 );
11139  _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
11140  }
11141  if (SWIG_IsTmpObj(res5)) {
11142  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11143  } else {
11144  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11145  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11146  }
11147  if (SWIG_IsTmpObj(res6)) {
11148  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11149  } else {
11150  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11151  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11152  }
11153  if (SWIG_IsTmpObj(res7)) {
11154  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11155  } else {
11156  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11157  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11158  }
11159  if (SWIG_IsTmpObj(res8)) {
11160  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11161  } else {
11162  int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11163  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11164  }
11165  if (SWIG_IsTmpObj(res9)) {
11166  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11167  } else {
11168  int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11169  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11170  }
11171  if (SWIG_IsTmpObj(res10)) {
11172  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11173  } else {
11174  int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11175  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11176  }
11177  if (SWIG_IsTmpObj(res11)) {
11178  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11179  } else {
11180  int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11181  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11182  }
11183  return _out;
11184  fail:
11185  return octave_value_list();
11186  }
11187  catch(...) {
11188  throw;
11189  }
11190 }
11191 
11192 
11193 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11194  PLFLT *arg1 = (PLFLT *) 0 ;
11195  PLFLT *arg2 = (PLFLT *) 0 ;
11196  PLFLT arg3 ;
11197  PLFLT arg4 ;
11198  PLFLT temp1 ;
11199  int res1 = SWIG_TMPOBJ ;
11200  PLFLT temp2 ;
11201  int res2 = SWIG_TMPOBJ ;
11202  double val3 ;
11203  int ecode3 = 0 ;
11204  double val4 ;
11205  int ecode4 = 0 ;
11206  octave_value_list _out;
11207  octave_value_list *_outp=&_out;
11208  octave_value _outv;
11209  int result;
11210 
11211  try {
11212  arg1 = &temp1;
11213  arg2 = &temp2;
11214  if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11215  SWIG_fail;
11216  }
11217  ecode3 = SWIG_AsVal_double(args(0), &val3);
11218  if (!SWIG_IsOK(ecode3)) {
11219  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11220  }
11221  arg3 = static_cast< PLFLT >(val3);
11222  ecode4 = SWIG_AsVal_double(args(1), &val4);
11223  if (!SWIG_IsOK(ecode4)) {
11224  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11225  }
11226  arg4 = static_cast< PLFLT >(val4);
11227  result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11228  _outv = SWIG_From_int(static_cast< int >(result));
11229  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11230  if (SWIG_IsTmpObj(res1)) {
11231  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11232  } else {
11233  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11234  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11235  }
11236  if (SWIG_IsTmpObj(res2)) {
11237  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11238  } else {
11239  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11240  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11241  }
11242  return _out;
11243  fail:
11244  return octave_value_list();
11245  }
11246  catch(...) {
11247  throw;
11248  }
11249 }
11250 
11251 
11253  PLINT *arg1 = (PLINT *) 0 ;
11254  char *arg2 = (char *) 0 ;
11255  char *arg3 = (char *) 0 ;
11256  PLFLT arg4 ;
11257  PLFLT arg5 ;
11258  PLFLT arg6 ;
11259  PLFLT arg7 ;
11260  PLFLT arg8 ;
11261  PLFLT arg9 ;
11262  PLFLT arg10 ;
11263  PLBOOL arg11 ;
11264  PLBOOL arg12 ;
11265  PLINT arg13 ;
11266  PLINT arg14 ;
11267  PLINT *arg15 = (PLINT *) 0 ;
11268  PLINT *arg16 = (PLINT *) 0 ;
11269  char *arg17 = (char *) 0 ;
11270  char *arg18 = (char *) 0 ;
11271  char *arg19 = (char *) 0 ;
11272  char *arg20 = (char *) 0 ;
11273  char *arg21 = (char *) 0 ;
11274  char *arg22 = (char *) 0 ;
11275  char *arg23 = (char *) 0 ;
11276  PLINT temp1 ;
11277  int res1 = SWIG_TMPOBJ ;
11278  int res2 ;
11279  char *buf2 = 0 ;
11280  int alloc2 = 0 ;
11281  int res3 ;
11282  char *buf3 = 0 ;
11283  int alloc3 = 0 ;
11284  double val4 ;
11285  int ecode4 = 0 ;
11286  double val5 ;
11287  int ecode5 = 0 ;
11288  double val6 ;
11289  int ecode6 = 0 ;
11290  double val7 ;
11291  int ecode7 = 0 ;
11292  double val8 ;
11293  int ecode8 = 0 ;
11294  double val9 ;
11295  int ecode9 = 0 ;
11296  double val10 ;
11297  int ecode10 = 0 ;
11298  int val11 ;
11299  int ecode11 = 0 ;
11300  int val12 ;
11301  int ecode12 = 0 ;
11302  int val13 ;
11303  int ecode13 = 0 ;
11304  int val14 ;
11305  int ecode14 = 0 ;
11306  Matrix temp15 ;
11307  Matrix temp16 ;
11308  int res17 ;
11309  char *buf17 = 0 ;
11310  int alloc17 = 0 ;
11311  int res18 ;
11312  char *buf18 = 0 ;
11313  int alloc18 = 0 ;
11314  int res19 ;
11315  char *buf19 = 0 ;
11316  int alloc19 = 0 ;
11317  int res20 ;
11318  char *buf20 = 0 ;
11319  int alloc20 = 0 ;
11320  int res21 ;
11321  char *buf21 = 0 ;
11322  int alloc21 = 0 ;
11323  int res22 ;
11324  char *buf22 = 0 ;
11325  int alloc22 = 0 ;
11326  int res23 ;
11327  char *buf23 = 0 ;
11328  int alloc23 = 0 ;
11329  octave_value_list _out;
11330  octave_value_list *_outp=&_out;
11331  octave_value _outv;
11332 
11333  try {
11334  arg1 = &temp1;
11335  if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11336  SWIG_fail;
11337  }
11338  res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11339  if (!SWIG_IsOK(res2)) {
11340  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11341  }
11342  arg2 = reinterpret_cast< char * >(buf2);
11343  res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11344  if (!SWIG_IsOK(res3)) {
11345  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11346  }
11347  arg3 = reinterpret_cast< char * >(buf3);
11348  ecode4 = SWIG_AsVal_double(args(2), &val4);
11349  if (!SWIG_IsOK(ecode4)) {
11350  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11351  }
11352  arg4 = static_cast< PLFLT >(val4);
11353  ecode5 = SWIG_AsVal_double(args(3), &val5);
11354  if (!SWIG_IsOK(ecode5)) {
11355  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11356  }
11357  arg5 = static_cast< PLFLT >(val5);
11358  ecode6 = SWIG_AsVal_double(args(4), &val6);
11359  if (!SWIG_IsOK(ecode6)) {
11360  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11361  }
11362  arg6 = static_cast< PLFLT >(val6);
11363  ecode7 = SWIG_AsVal_double(args(5), &val7);
11364  if (!SWIG_IsOK(ecode7)) {
11365  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11366  }
11367  arg7 = static_cast< PLFLT >(val7);
11368  ecode8 = SWIG_AsVal_double(args(6), &val8);
11369  if (!SWIG_IsOK(ecode8)) {
11370  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11371  }
11372  arg8 = static_cast< PLFLT >(val8);
11373  ecode9 = SWIG_AsVal_double(args(7), &val9);
11374  if (!SWIG_IsOK(ecode9)) {
11375  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11376  }
11377  arg9 = static_cast< PLFLT >(val9);
11378  ecode10 = SWIG_AsVal_double(args(8), &val10);
11379  if (!SWIG_IsOK(ecode10)) {
11380  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11381  }
11382  arg10 = static_cast< PLFLT >(val10);
11383  ecode11 = SWIG_AsVal_int(args(9), &val11);
11384  if (!SWIG_IsOK(ecode11)) {
11385  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11386  }
11387  arg11 = static_cast< PLBOOL >(val11);
11388  ecode12 = SWIG_AsVal_int(args(10), &val12);
11389  if (!SWIG_IsOK(ecode12)) {
11390  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11391  }
11392  arg12 = static_cast< PLBOOL >(val12);
11393  ecode13 = SWIG_AsVal_int(args(11), &val13);
11394  if (!SWIG_IsOK(ecode13)) {
11395  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11396  }
11397  arg13 = static_cast< PLINT >(val13);
11398  ecode14 = SWIG_AsVal_int(args(12), &val14);
11399  if (!SWIG_IsOK(ecode14)) {
11400  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11401  }
11402  arg14 = static_cast< PLINT >(val14);
11403  {
11404  if ( _n_dims( args(13) ) > 1 )
11405  {
11406  error( "argument must be a scalar or vector" ); SWIG_fail;
11407  }
11408  Alen = (PLINT) ( _dim( args(13), 0 ) );
11409  temp15 = args(13).matrix_value();
11410  arg15 = new PLINT[Alen];
11411  _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11412  }
11413  {
11414  if ( _n_dims( args(14) ) > 1 )
11415  {
11416  error( "argument must be a scalar or vector" ); SWIG_fail;
11417  }
11418  if ( _dim( args(14), 0 ) != Alen )
11419  {
11420  error( "argument vectors must be same length" ); SWIG_fail;
11421  }
11422  temp16 = args(14).matrix_value();
11423  arg16 = new PLINT[Alen];
11424  _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11425  }
11426  res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11427  if (!SWIG_IsOK(res17)) {
11428  SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11429  }
11430  arg17 = reinterpret_cast< char * >(buf17);
11431  res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11432  if (!SWIG_IsOK(res18)) {
11433  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11434  }
11435  arg18 = reinterpret_cast< char * >(buf18);
11436  res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11437  if (!SWIG_IsOK(res19)) {
11438  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11439  }
11440  arg19 = reinterpret_cast< char * >(buf19);
11441  res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11442  if (!SWIG_IsOK(res20)) {
11443  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11444  }
11445  arg20 = reinterpret_cast< char * >(buf20);
11446  res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11447  if (!SWIG_IsOK(res21)) {
11448  SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11449  }
11450  arg21 = reinterpret_cast< char * >(buf21);
11451  res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11452  if (!SWIG_IsOK(res22)) {
11453  SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11454  }
11455  arg22 = reinterpret_cast< char * >(buf22);
11456  res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11457  if (!SWIG_IsOK(res23)) {
11458  SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11459  }
11460  arg23 = reinterpret_cast< char * >(buf23);
11461  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);
11462  _outv = octave_value();
11463  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11464  if (SWIG_IsTmpObj(res1)) {
11465  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11466  } else {
11467  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11468  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11469  }
11470  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11471  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11472  {
11473  delete [] arg15;
11474  }
11475  {
11476  delete [] arg16;
11477  }
11478  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11479  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11480  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11481  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11482  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11483  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11484  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11485  return _out;
11486  fail:
11487  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11488  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11489  {
11490  delete [] arg15;
11491  }
11492  {
11493  delete [] arg16;
11494  }
11495  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11496  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11497  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11498  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11499  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11500  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11501  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11502  return octave_value_list();
11503  }
11504  catch(...) {
11505  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11506  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11507  {
11508  delete [] arg15;
11509  }
11510  {
11511  delete [] arg16;
11512  }
11513  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11514  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11515  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11516  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11517  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11518  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11519  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11520  throw;
11521  }
11522 }
11523 
11524 
11526  PLFLT *arg1 = (PLFLT *) 0 ;
11527  PLINT arg2 ;
11528  PLINT arg3 ;
11529  PLINT arg4 ;
11530  PLINT arg5 ;
11531  PLINT arg6 ;
11532  PLINT arg7 ;
11533  PLFLT *arg8 = (PLFLT *) 0 ;
11534  PLINT arg9 ;
11535  PLFLT *arg10 = (PLFLT *) 0 ;
11536  Matrix temp1 ;
11537  int val4 ;
11538  int ecode4 = 0 ;
11539  int val5 ;
11540  int ecode5 = 0 ;
11541  int val6 ;
11542  int ecode6 = 0 ;
11543  int val7 ;
11544  int ecode7 = 0 ;
11545  Matrix temp8 ;
11546  Matrix temp10 ;
11547  octave_value_list _out;
11548  octave_value_list *_outp=&_out;
11549  octave_value _outv;
11550 
11551  try {
11552  if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11553  SWIG_fail;
11554  }
11555  {
11556  if ( _n_dims( args(0) ) > 2 )
11557  {
11558  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11559  }
11560  temp1 = args(0).matrix_value();
11561  arg1 = &temp1( 0, 0 );
11562  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11563  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11564  }
11565  ecode4 = SWIG_AsVal_int(args(1), &val4);
11566  if (!SWIG_IsOK(ecode4)) {
11567  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11568  }
11569  arg4 = static_cast< PLINT >(val4);
11570  ecode5 = SWIG_AsVal_int(args(2), &val5);
11571  if (!SWIG_IsOK(ecode5)) {
11572  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11573  }
11574  arg5 = static_cast< PLINT >(val5);
11575  ecode6 = SWIG_AsVal_int(args(3), &val6);
11576  if (!SWIG_IsOK(ecode6)) {
11577  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11578  }
11579  arg6 = static_cast< PLINT >(val6);
11580  ecode7 = SWIG_AsVal_int(args(4), &val7);
11581  if (!SWIG_IsOK(ecode7)) {
11582  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11583  }
11584  arg7 = static_cast< PLINT >(val7);
11585  {
11586  if ( _n_dims( args(5) ) > 1 )
11587  {
11588  error( "argument must be a scalar or vector" ); SWIG_fail;
11589  }
11590  temp8 = args(5).matrix_value();
11591  arg8 = &temp8( 0, 0 );
11592  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11593  }
11594  {
11595  if ( _n_dims( args(6) ) > 1 )
11596  {
11597  error( "argument must be a scalar or vector" ); SWIG_fail;
11598  }
11599  if ( _dim( args(6), 0 ) != 6 )
11600  {
11601  error( "argument vectors must have length of 6" ); SWIG_fail;
11602  }
11603  temp10 = args(6).matrix_value();
11604  arg10 = &temp10( 0, 0 );
11605  }
11606  my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11607  _outv = octave_value();
11608  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11609  {
11610 
11611  }
11612  {
11613 
11614  }
11615  {
11616 
11617  }
11618  return _out;
11619  fail:
11620  {
11621 
11622  }
11623  {
11624 
11625  }
11626  {
11627 
11628  }
11629  return octave_value_list();
11630  }
11631  catch(...) {
11632  {
11633 
11634  }
11635  {
11636 
11637  }
11638  {
11639 
11640  }
11641  throw;
11642  }
11643 }
11644 
11645 
11646 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11647  PLFLT *arg1 = (PLFLT *) 0 ;
11648  PLINT arg2 ;
11649  PLINT arg3 ;
11650  PLINT arg4 ;
11651  PLINT arg5 ;
11652  PLINT arg6 ;
11653  PLINT arg7 ;
11654  PLFLT *arg8 = (PLFLT *) 0 ;
11655  PLINT arg9 ;
11656  Matrix temp1 ;
11657  int val4 ;
11658  int ecode4 = 0 ;
11659  int val5 ;
11660  int ecode5 = 0 ;
11661  int val6 ;
11662  int ecode6 = 0 ;
11663  int val7 ;
11664  int ecode7 = 0 ;
11665  Matrix temp8 ;
11666  octave_value_list _out;
11667  octave_value_list *_outp=&_out;
11668  octave_value _outv;
11669 
11670  try {
11671  if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11672  SWIG_fail;
11673  }
11674  {
11675  if ( _n_dims( args(0) ) > 2 )
11676  {
11677  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11678  }
11679  temp1 = args(0).matrix_value();
11680  arg1 = &temp1( 0, 0 );
11681  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11682  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11683  }
11684  ecode4 = SWIG_AsVal_int(args(1), &val4);
11685  if (!SWIG_IsOK(ecode4)) {
11686  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11687  }
11688  arg4 = static_cast< PLINT >(val4);
11689  ecode5 = SWIG_AsVal_int(args(2), &val5);
11690  if (!SWIG_IsOK(ecode5)) {
11691  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11692  }
11693  arg5 = static_cast< PLINT >(val5);
11694  ecode6 = SWIG_AsVal_int(args(3), &val6);
11695  if (!SWIG_IsOK(ecode6)) {
11696  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11697  }
11698  arg6 = static_cast< PLINT >(val6);
11699  ecode7 = SWIG_AsVal_int(args(4), &val7);
11700  if (!SWIG_IsOK(ecode7)) {
11701  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11702  }
11703  arg7 = static_cast< PLINT >(val7);
11704  {
11705  if ( _n_dims( args(5) ) > 1 )
11706  {
11707  error( "argument must be a scalar or vector" ); SWIG_fail;
11708  }
11709  temp8 = args(5).matrix_value();
11710  arg8 = &temp8( 0, 0 );
11711  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11712  }
11713  my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11714  _outv = octave_value();
11715  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11716  {
11717 
11718  }
11719  {
11720 
11721  }
11722  return _out;
11723  fail:
11724  {
11725 
11726  }
11727  {
11728 
11729  }
11730  return octave_value_list();
11731  }
11732  catch(...) {
11733  {
11734 
11735  }
11736  {
11737 
11738  }
11739  throw;
11740  }
11741 }
11742 
11743 
11744 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11745  PLFLT *arg1 = (PLFLT *) 0 ;
11746  PLINT arg2 ;
11747  PLINT arg3 ;
11748  PLINT arg4 ;
11749  PLINT arg5 ;
11750  PLINT arg6 ;
11751  PLINT arg7 ;
11752  PLFLT *arg8 = (PLFLT *) 0 ;
11753  PLINT arg9 ;
11754  PLFLT *arg10 = (PLFLT *) 0 ;
11755  PLFLT *arg11 = (PLFLT *) 0 ;
11756  Matrix temp1 ;
11757  int val4 ;
11758  int ecode4 = 0 ;
11759  int val5 ;
11760  int ecode5 = 0 ;
11761  int val6 ;
11762  int ecode6 = 0 ;
11763  int val7 ;
11764  int ecode7 = 0 ;
11765  Matrix temp8 ;
11766  Matrix temp10 ;
11767  Matrix temp11 ;
11768  octave_value_list _out;
11769  octave_value_list *_outp=&_out;
11770  octave_value _outv;
11771 
11772  try {
11773  if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11774  SWIG_fail;
11775  }
11776  {
11777  if ( _n_dims( args(0) ) > 2 )
11778  {
11779  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11780  }
11781  temp1 = args(0).matrix_value();
11782  arg1 = &temp1( 0, 0 );
11783  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11784  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11785  }
11786  ecode4 = SWIG_AsVal_int(args(1), &val4);
11787  if (!SWIG_IsOK(ecode4)) {
11788  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11789  }
11790  arg4 = static_cast< PLINT >(val4);
11791  ecode5 = SWIG_AsVal_int(args(2), &val5);
11792  if (!SWIG_IsOK(ecode5)) {
11793  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11794  }
11795  arg5 = static_cast< PLINT >(val5);
11796  ecode6 = SWIG_AsVal_int(args(3), &val6);
11797  if (!SWIG_IsOK(ecode6)) {
11798  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11799  }
11800  arg6 = static_cast< PLINT >(val6);
11801  ecode7 = SWIG_AsVal_int(args(4), &val7);
11802  if (!SWIG_IsOK(ecode7)) {
11803  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11804  }
11805  arg7 = static_cast< PLINT >(val7);
11806  {
11807  if ( _n_dims( args(5) ) > 1 )
11808  {
11809  error( "argument must be a scalar or vector" ); SWIG_fail;
11810  }
11811  temp8 = args(5).matrix_value();
11812  arg8 = &temp8( 0, 0 );
11813  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11814  }
11815  {
11816  if ( _n_dims( args(6) ) > 1 )
11817  {
11818  error( "argument must be a scalar or vector" ); SWIG_fail;
11819  }
11820  if ( _dim( args(6), 0 ) != Xlen )
11821  {
11822  error( "argument vectors must be same length" ); SWIG_fail;
11823  }
11824  temp10 = args(6).matrix_value();
11825  arg10 = &temp10( 0, 0 );
11826  }
11827  {
11828  if ( _n_dims( args(7) ) > 1 )
11829  {
11830  error( "argument must be a scalar or vector" ); SWIG_fail;
11831  }
11832  if ( _dim( args(7), 0 ) != Ylen )
11833  {
11834  error( "argument vectors must be same length" ); SWIG_fail;
11835  }
11836  temp11 = args(7).matrix_value();
11837  arg11 = &temp11( 0, 0 );
11838  }
11839  my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11840  _outv = octave_value();
11841  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11842  {
11843 
11844  }
11845  {
11846 
11847  }
11848  {
11849 
11850  }
11851  {
11852 
11853  }
11854  return _out;
11855  fail:
11856  {
11857 
11858  }
11859  {
11860 
11861  }
11862  {
11863 
11864  }
11865  {
11866 
11867  }
11868  return octave_value_list();
11869  }
11870  catch(...) {
11871  {
11872 
11873  }
11874  {
11875 
11876  }
11877  {
11878 
11879  }
11880  {
11881 
11882  }
11883  throw;
11884  }
11885 }
11886 
11887 
11888 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
11889  PLFLT *arg1 = (PLFLT *) 0 ;
11890  PLINT arg2 ;
11891  PLINT arg3 ;
11892  PLINT arg4 ;
11893  PLINT arg5 ;
11894  PLINT arg6 ;
11895  PLINT arg7 ;
11896  PLFLT *arg8 = (PLFLT *) 0 ;
11897  PLINT arg9 ;
11898  PLFLT *arg10 = (PLFLT *) 0 ;
11899  PLFLT *arg11 = (PLFLT *) 0 ;
11900  Matrix temp1 ;
11901  int val4 ;
11902  int ecode4 = 0 ;
11903  int val5 ;
11904  int ecode5 = 0 ;
11905  int val6 ;
11906  int ecode6 = 0 ;
11907  int val7 ;
11908  int ecode7 = 0 ;
11909  Matrix temp8 ;
11910  Matrix temp10 ;
11911  Matrix temp11 ;
11912  octave_value_list _out;
11913  octave_value_list *_outp=&_out;
11914  octave_value _outv;
11915 
11916  try {
11917  if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11918  SWIG_fail;
11919  }
11920  {
11921  if ( _n_dims( args(0) ) > 2 )
11922  {
11923  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11924  }
11925  temp1 = args(0).matrix_value();
11926  arg1 = &temp1( 0, 0 );
11927  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11928  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11929  }
11930  ecode4 = SWIG_AsVal_int(args(1), &val4);
11931  if (!SWIG_IsOK(ecode4)) {
11932  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11933  }
11934  arg4 = static_cast< PLINT >(val4);
11935  ecode5 = SWIG_AsVal_int(args(2), &val5);
11936  if (!SWIG_IsOK(ecode5)) {
11937  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11938  }
11939  arg5 = static_cast< PLINT >(val5);
11940  ecode6 = SWIG_AsVal_int(args(3), &val6);
11941  if (!SWIG_IsOK(ecode6)) {
11942  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
11943  }
11944  arg6 = static_cast< PLINT >(val6);
11945  ecode7 = SWIG_AsVal_int(args(4), &val7);
11946  if (!SWIG_IsOK(ecode7)) {
11947  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
11948  }
11949  arg7 = static_cast< PLINT >(val7);
11950  {
11951  if ( _n_dims( args(5) ) > 1 )
11952  {
11953  error( "argument must be a scalar or vector" ); SWIG_fail;
11954  }
11955  temp8 = args(5).matrix_value();
11956  arg8 = &temp8( 0, 0 );
11957  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11958  }
11959  {
11960  if ( _n_dims( args(6) ) > 2 )
11961  {
11962  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11963  }
11964  if ( _dim( args(6), 0 ) != Xlen )
11965  {
11966  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11967  }
11968  if ( _dim( args(6), 1 ) != Ylen )
11969  {
11970  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11971  }
11972  temp10 = args(6).matrix_value();
11973  arg10 = &temp10( 0, 0 );
11974  }
11975  {
11976  if ( _n_dims( args(7) ) > 2 )
11977  {
11978  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11979  }
11980  if ( _dim( args(7), 0 ) != Xlen )
11981  {
11982  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11983  }
11984  if ( _dim( args(7), 1 ) != Ylen )
11985  {
11986  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11987  }
11988  temp11 = args(7).matrix_value();
11989  arg11 = &temp11( 0, 0 );
11990  }
11991  my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11992  _outv = octave_value();
11993  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11994  {
11995 
11996  }
11997  {
11998 
11999  }
12000  {
12001 
12002  }
12003  {
12004 
12005  }
12006  return _out;
12007  fail:
12008  {
12009 
12010  }
12011  {
12012 
12013  }
12014  {
12015 
12016  }
12017  {
12018 
12019  }
12020  return octave_value_list();
12021  }
12022  catch(...) {
12023  {
12024 
12025  }
12026  {
12027 
12028  }
12029  {
12030 
12031  }
12032  {
12033 
12034  }
12035  throw;
12036  }
12037 }
12038 
12039 
12040 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
12041  PLFLT *arg1 = (PLFLT *) 0 ;
12042  PLINT arg2 ;
12043  PLINT arg3 ;
12044  PLINT arg4 ;
12045  PLINT arg5 ;
12046  PLINT arg6 ;
12047  PLINT arg7 ;
12048  PLFLT *arg8 = (PLFLT *) 0 ;
12049  PLINT arg9 ;
12050  PLFLT *arg10 = (PLFLT *) 0 ;
12051  PLFLT *arg11 = (PLFLT *) 0 ;
12052  Matrix temp1 ;
12053  int val4 ;
12054  int ecode4 = 0 ;
12055  int val5 ;
12056  int ecode5 = 0 ;
12057  int val6 ;
12058  int ecode6 = 0 ;
12059  int val7 ;
12060  int ecode7 = 0 ;
12061  Matrix temp8 ;
12062  Matrix temp10 ;
12063  Matrix temp11 ;
12064  octave_value_list _out;
12065  octave_value_list *_outp=&_out;
12066  octave_value _outv;
12067 
12068  try {
12069  if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
12070  SWIG_fail;
12071  }
12072  {
12073  if ( _n_dims( args(0) ) > 2 )
12074  {
12075  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12076  }
12077  temp1 = args(0).matrix_value();
12078  arg1 = &temp1( 0, 0 );
12079  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12080  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12081  }
12082  ecode4 = SWIG_AsVal_int(args(1), &val4);
12083  if (!SWIG_IsOK(ecode4)) {
12084  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
12085  }
12086  arg4 = static_cast< PLINT >(val4);
12087  ecode5 = SWIG_AsVal_int(args(2), &val5);
12088  if (!SWIG_IsOK(ecode5)) {
12089  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
12090  }
12091  arg5 = static_cast< PLINT >(val5);
12092  ecode6 = SWIG_AsVal_int(args(3), &val6);
12093  if (!SWIG_IsOK(ecode6)) {
12094  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
12095  }
12096  arg6 = static_cast< PLINT >(val6);
12097  ecode7 = SWIG_AsVal_int(args(4), &val7);
12098  if (!SWIG_IsOK(ecode7)) {
12099  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
12100  }
12101  arg7 = static_cast< PLINT >(val7);
12102  {
12103  if ( _n_dims( args(5) ) > 1 )
12104  {
12105  error( "argument must be a scalar or vector" ); SWIG_fail;
12106  }
12107  temp8 = args(5).matrix_value();
12108  arg8 = &temp8( 0, 0 );
12109  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
12110  }
12111  {
12112  if ( _n_dims( args(6) ) > 2 )
12113  {
12114  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12115  }
12116  if ( _dim( args(6), 0 ) != Xlen )
12117  {
12118  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12119  }
12120  if ( _dim( args(6), 1 ) != Ylen )
12121  {
12122  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12123  }
12124  temp10 = args(6).matrix_value();
12125  arg10 = &temp10( 0, 0 );
12126  }
12127  {
12128  if ( _n_dims( args(7) ) > 2 )
12129  {
12130  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12131  }
12132  if ( _dim( args(7), 0 ) != Xlen )
12133  {
12134  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12135  }
12136  if ( _dim( args(7), 1 ) != Ylen )
12137  {
12138  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12139  }
12140  temp11 = args(7).matrix_value();
12141  arg11 = &temp11( 0, 0 );
12142  }
12143  my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
12144  _outv = octave_value();
12145  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12146  {
12147 
12148  }
12149  {
12150 
12151  }
12152  {
12153 
12154  }
12155  {
12156 
12157  }
12158  return _out;
12159  fail:
12160  {
12161 
12162  }
12163  {
12164 
12165  }
12166  {
12167 
12168  }
12169  {
12170 
12171  }
12172  return octave_value_list();
12173  }
12174  catch(...) {
12175  {
12176 
12177  }
12178  {
12179 
12180  }
12181  {
12182 
12183  }
12184  {
12185 
12186  }
12187  throw;
12188  }
12189 }
12190 
12191 
12193  PLFLT *arg1 = (PLFLT *) 0 ;
12194  PLFLT *arg2 = (PLFLT *) 0 ;
12195  PLFLT *arg3 = (PLFLT *) 0 ;
12196  PLINT arg4 ;
12197  PLFLT *arg5 = (PLFLT *) 0 ;
12198  PLINT arg6 ;
12199  PLFLT *arg7 = (PLFLT *) 0 ;
12200  PLINT arg8 ;
12201  PLFLT *arg9 = (PLFLT *) 0 ;
12202  PLINT arg10 ;
12203  PLFLT arg11 ;
12204  Matrix temp1 ;
12205  Matrix temp2 ;
12206  Matrix temp3 ;
12207  Matrix temp5 ;
12208  Matrix temp7 ;
12209  octave_value_list retval7 ;
12210  int val10 ;
12211  int ecode10 = 0 ;
12212  double val11 ;
12213  int ecode11 = 0 ;
12214  octave_value_list _out;
12215  octave_value_list *_outp=&_out;
12216  octave_value _outv;
12217 
12218  try {
12219  if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
12220  SWIG_fail;
12221  }
12222  {
12223  if ( _n_dims( args(0) ) > 1 )
12224  {
12225  error( "argument must be a scalar or vector" ); SWIG_fail;
12226  }
12227  Alen = (PLINT) ( _dim( args(0), 0 ) );
12228  temp1 = args(0).matrix_value();
12229  arg1 = &temp1( 0, 0 );
12230  }
12231  {
12232  if ( _n_dims( args(1) ) > 1 )
12233  {
12234  error( "argument must be a scalar or vector" ); SWIG_fail;
12235  }
12236  if ( _dim( args(1), 0 ) != Alen )
12237  {
12238  error( "argument vectors must be same length" ); SWIG_fail;
12239  }
12240  temp2 = args(1).matrix_value();
12241  arg2 = &temp2( 0, 0 );
12242  }
12243  {
12244  if ( _n_dims( args(2) ) > 1 )
12245  {
12246  error( "argument must be a scalar or vector" ); SWIG_fail;
12247  }
12248  if ( _dim( args(2), 0 ) != Alen )
12249  {
12250  error( "argument vectors must be same length" ); SWIG_fail;
12251  }
12252  temp3 = args(2).matrix_value();
12253  arg3 = &temp3( 0, 0 );
12254  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12255  }
12256  {
12257  if ( _n_dims( args(3) ) > 1 )
12258  {
12259  error( "argument must be a scalar or vector" ); SWIG_fail;
12260  }
12261  temp5 = args(3).matrix_value();
12262  arg5 = &temp5( 0, 0 );
12263  arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12264  }
12265  {
12266  if ( _n_dims( args(4) ) > 1 )
12267  {
12268  error( "argument must be a scalar or vector" ); SWIG_fail;
12269  }
12270  temp7 = args(4).matrix_value();
12271  arg7 = &temp7( 0, 0 );
12272  arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12273  retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12274  arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12275  }
12276  ecode10 = SWIG_AsVal_int(args(5), &val10);
12277  if (!SWIG_IsOK(ecode10)) {
12278  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12279  }
12280  arg10 = static_cast< PLINT >(val10);
12281  ecode11 = SWIG_AsVal_double(args(6), &val11);
12282  if (!SWIG_IsOK(ecode11)) {
12283  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12284  }
12285  arg11 = static_cast< PLFLT >(val11);
12286  my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12287  _outv = octave_value();
12288  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12289  {
12290  _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
12291  }
12292  {
12293 
12294  }
12295  {
12296 
12297  }
12298  {
12299 
12300  }
12301  {
12302 
12303  }
12304  {
12305 
12306  }
12307  return _out;
12308  fail:
12309  {
12310 
12311  }
12312  {
12313 
12314  }
12315  {
12316 
12317  }
12318  {
12319 
12320  }
12321  {
12322 
12323  }
12324  return octave_value_list();
12325  }
12326  catch(...) {
12327  {
12328 
12329  }
12330  {
12331 
12332  }
12333  {
12334 
12335  }
12336  {
12337 
12338  }
12339  {
12340 
12341  }
12342  throw;
12343  }
12344 }
12345 
12346 
12348  PLFLT *arg1 = (PLFLT *) 0 ;
12349  PLFLT *arg2 = (PLFLT *) 0 ;
12350  PLFLT *arg3 = (PLFLT *) 0 ;
12351  PLINT arg4 ;
12352  PLINT arg5 ;
12353  PLINT arg6 ;
12354  Matrix temp1 ;
12355  Matrix temp2 ;
12356  Matrix temp3 ;
12357  int val6 ;
12358  int ecode6 = 0 ;
12359  octave_value_list _out;
12360  octave_value_list *_outp=&_out;
12361  octave_value _outv;
12362 
12363  try {
12364  if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12365  SWIG_fail;
12366  }
12367  {
12368  if ( _n_dims( args(0) ) > 1 )
12369  {
12370  error( "argument must be a scalar or vector" ); SWIG_fail;
12371  }
12372  temp1 = args(0).matrix_value();
12373  arg1 = &temp1( 0, 0 );
12374  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12375  }
12376  {
12377  if ( _n_dims( args(1) ) > 1 )
12378  {
12379  error( "argument must be a scalar or vector" ); SWIG_fail;
12380  }
12381  temp2 = args(1).matrix_value();
12382  arg2 = &temp2( 0, 0 );
12383  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12384  }
12385  {
12386  if ( _n_dims( args(2) ) > 2 )
12387  {
12388  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12389  }
12390  if ( _dim( args(2), 0 ) != Xlen )
12391  {
12392  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12393  }
12394  if ( _dim( args(2), 1 ) != Ylen )
12395  {
12396  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12397  }
12398  temp3 = args(2).matrix_value();
12399  arg3 = &temp3( 0, 0 );
12400  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12401  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12402  }
12403  ecode6 = SWIG_AsVal_int(args(3), &val6);
12404  if (!SWIG_IsOK(ecode6)) {
12405  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12406  }
12407  arg6 = static_cast< PLINT >(val6);
12408  my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12409  _outv = octave_value();
12410  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12411  {
12412 
12413  }
12414  {
12415 
12416  }
12417  {
12418 
12419  }
12420  return _out;
12421  fail:
12422  {
12423 
12424  }
12425  {
12426 
12427  }
12428  {
12429 
12430  }
12431  return octave_value_list();
12432  }
12433  catch(...) {
12434  {
12435 
12436  }
12437  {
12438 
12439  }
12440  {
12441 
12442  }
12443  throw;
12444  }
12445 }
12446 
12447 
12449  PLFLT *arg1 = (PLFLT *) 0 ;
12450  PLFLT *arg2 = (PLFLT *) 0 ;
12451  PLFLT *arg3 = (PLFLT *) 0 ;
12452  PLINT arg4 ;
12453  PLINT arg5 ;
12454  PLINT arg6 ;
12455  PLFLT *arg7 = (PLFLT *) 0 ;
12456  PLINT arg8 ;
12457  Matrix temp1 ;
12458  Matrix temp2 ;
12459  Matrix temp3 ;
12460  int val6 ;
12461  int ecode6 = 0 ;
12462  Matrix temp7 ;
12463  octave_value_list _out;
12464  octave_value_list *_outp=&_out;
12465  octave_value _outv;
12466 
12467  try {
12468  if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12469  SWIG_fail;
12470  }
12471  {
12472  if ( _n_dims( args(0) ) > 1 )
12473  {
12474  error( "argument must be a scalar or vector" ); SWIG_fail;
12475  }
12476  temp1 = args(0).matrix_value();
12477  arg1 = &temp1( 0, 0 );
12478  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12479  }
12480  {
12481  if ( _n_dims( args(1) ) > 1 )
12482  {
12483  error( "argument must be a scalar or vector" ); SWIG_fail;
12484  }
12485  temp2 = args(1).matrix_value();
12486  arg2 = &temp2( 0, 0 );
12487  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12488  }
12489  {
12490  if ( _n_dims( args(2) ) > 2 )
12491  {
12492  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12493  }
12494  if ( _dim( args(2), 0 ) != Xlen )
12495  {
12496  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12497  }
12498  if ( _dim( args(2), 1 ) != Ylen )
12499  {
12500  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12501  }
12502  temp3 = args(2).matrix_value();
12503  arg3 = &temp3( 0, 0 );
12504  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12505  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12506  }
12507  ecode6 = SWIG_AsVal_int(args(3), &val6);
12508  if (!SWIG_IsOK(ecode6)) {
12509  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12510  }
12511  arg6 = static_cast< PLINT >(val6);
12512  {
12513  if ( _n_dims( args(4) ) > 1 )
12514  {
12515  error( "argument must be a scalar or vector" ); SWIG_fail;
12516  }
12517  temp7 = args(4).matrix_value();
12518  arg7 = &temp7( 0, 0 );
12519  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12520  }
12521  my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12522  _outv = octave_value();
12523  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12524  {
12525 
12526  }
12527  {
12528 
12529  }
12530  {
12531 
12532  }
12533  {
12534 
12535  }
12536  return _out;
12537  fail:
12538  {
12539 
12540  }
12541  {
12542 
12543  }
12544  {
12545 
12546  }
12547  {
12548 
12549  }
12550  return octave_value_list();
12551  }
12552  catch(...) {
12553  {
12554 
12555  }
12556  {
12557 
12558  }
12559  {
12560 
12561  }
12562  {
12563 
12564  }
12565  throw;
12566  }
12567 }
12568 
12569 
12571  PLFLT *arg1 = (PLFLT *) 0 ;
12572  PLFLT *arg2 = (PLFLT *) 0 ;
12573  PLFLT *arg3 = (PLFLT *) 0 ;
12574  PLINT arg4 ;
12575  PLINT arg5 ;
12576  PLINT arg6 ;
12577  PLBOOL arg7 ;
12578  Matrix temp1 ;
12579  Matrix temp2 ;
12580  Matrix temp3 ;
12581  int val6 ;
12582  int ecode6 = 0 ;
12583  int val7 ;
12584  int ecode7 = 0 ;
12585  octave_value_list _out;
12586  octave_value_list *_outp=&_out;
12587  octave_value _outv;
12588 
12589  try {
12590  if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12591  SWIG_fail;
12592  }
12593  {
12594  if ( _n_dims( args(0) ) > 1 )
12595  {
12596  error( "argument must be a scalar or vector" ); SWIG_fail;
12597  }
12598  temp1 = args(0).matrix_value();
12599  arg1 = &temp1( 0, 0 );
12600  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12601  }
12602  {
12603  if ( _n_dims( args(1) ) > 1 )
12604  {
12605  error( "argument must be a scalar or vector" ); SWIG_fail;
12606  }
12607  temp2 = args(1).matrix_value();
12608  arg2 = &temp2( 0, 0 );
12609  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12610  }
12611  {
12612  if ( _n_dims( args(2) ) > 2 )
12613  {
12614  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12615  }
12616  if ( _dim( args(2), 0 ) != Xlen )
12617  {
12618  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12619  }
12620  if ( _dim( args(2), 1 ) != Ylen )
12621  {
12622  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12623  }
12624  temp3 = args(2).matrix_value();
12625  arg3 = &temp3( 0, 0 );
12626  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12627  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12628  }
12629  ecode6 = SWIG_AsVal_int(args(3), &val6);
12630  if (!SWIG_IsOK(ecode6)) {
12631  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12632  }
12633  arg6 = static_cast< PLINT >(val6);
12634  ecode7 = SWIG_AsVal_int(args(4), &val7);
12635  if (!SWIG_IsOK(ecode7)) {
12636  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12637  }
12638  arg7 = static_cast< PLBOOL >(val7);
12639  my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12640  _outv = octave_value();
12641  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12642  {
12643 
12644  }
12645  {
12646 
12647  }
12648  {
12649 
12650  }
12651  return _out;
12652  fail:
12653  {
12654 
12655  }
12656  {
12657 
12658  }
12659  {
12660 
12661  }
12662  return octave_value_list();
12663  }
12664  catch(...) {
12665  {
12666 
12667  }
12668  {
12669 
12670  }
12671  {
12672 
12673  }
12674  throw;
12675  }
12676 }
12677 
12678 
12680  PLFLT *arg1 = (PLFLT *) 0 ;
12681  PLFLT *arg2 = (PLFLT *) 0 ;
12682  PLFLT *arg3 = (PLFLT *) 0 ;
12683  PLINT arg4 ;
12684  PLINT arg5 ;
12685  PLINT arg6 ;
12686  PLFLT *arg7 = (PLFLT *) 0 ;
12687  PLINT arg8 ;
12688  Matrix temp1 ;
12689  Matrix temp2 ;
12690  Matrix temp3 ;
12691  int val6 ;
12692  int ecode6 = 0 ;
12693  Matrix temp7 ;
12694  octave_value_list _out;
12695  octave_value_list *_outp=&_out;
12696  octave_value _outv;
12697 
12698  try {
12699  if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12700  SWIG_fail;
12701  }
12702  {
12703  if ( _n_dims( args(0) ) > 1 )
12704  {
12705  error( "argument must be a scalar or vector" ); SWIG_fail;
12706  }
12707  temp1 = args(0).matrix_value();
12708  arg1 = &temp1( 0, 0 );
12709  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12710  }
12711  {
12712  if ( _n_dims( args(1) ) > 1 )
12713  {
12714  error( "argument must be a scalar or vector" ); SWIG_fail;
12715  }
12716  temp2 = args(1).matrix_value();
12717  arg2 = &temp2( 0, 0 );
12718  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12719  }
12720  {
12721  if ( _n_dims( args(2) ) > 2 )
12722  {
12723  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12724  }
12725  if ( _dim( args(2), 0 ) != Xlen )
12726  {
12727  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12728  }
12729  if ( _dim( args(2), 1 ) != Ylen )
12730  {
12731  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12732  }
12733  temp3 = args(2).matrix_value();
12734  arg3 = &temp3( 0, 0 );
12735  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12736  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12737  }
12738  ecode6 = SWIG_AsVal_int(args(3), &val6);
12739  if (!SWIG_IsOK(ecode6)) {
12740  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12741  }
12742  arg6 = static_cast< PLINT >(val6);
12743  {
12744  if ( _n_dims( args(4) ) > 1 )
12745  {
12746  error( "argument must be a scalar or vector" ); SWIG_fail;
12747  }
12748  temp7 = args(4).matrix_value();
12749  arg7 = &temp7( 0, 0 );
12750  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12751  }
12752  my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12753  _outv = octave_value();
12754  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12755  {
12756 
12757  }
12758  {
12759 
12760  }
12761  {
12762 
12763  }
12764  {
12765 
12766  }
12767  return _out;
12768  fail:
12769  {
12770 
12771  }
12772  {
12773 
12774  }
12775  {
12776 
12777  }
12778  {
12779 
12780  }
12781  return octave_value_list();
12782  }
12783  catch(...) {
12784  {
12785 
12786  }
12787  {
12788 
12789  }
12790  {
12791 
12792  }
12793  {
12794 
12795  }
12796  throw;
12797  }
12798 }
12799 
12800 
12802  PLFLT *arg1 = (PLFLT *) 0 ;
12803  PLFLT *arg2 = (PLFLT *) 0 ;
12804  PLFLT *arg3 = (PLFLT *) 0 ;
12805  PLINT arg4 ;
12806  PLINT arg5 ;
12807  PLINT arg6 ;
12808  PLFLT *arg7 = (PLFLT *) 0 ;
12809  PLINT arg8 ;
12810  PLINT arg9 ;
12811  PLINT arg10 ;
12812  PLINT *arg11 = (PLINT *) 0 ;
12813  PLINT *arg12 = (PLINT *) 0 ;
12814  Matrix temp1 ;
12815  Matrix temp2 ;
12816  Matrix temp3 ;
12817  int val6 ;
12818  int ecode6 = 0 ;
12819  Matrix temp7 ;
12820  int val9 ;
12821  int ecode9 = 0 ;
12822  Matrix temp10 ;
12823  Matrix temp12 ;
12824  octave_value_list _out;
12825  octave_value_list *_outp=&_out;
12826  octave_value _outv;
12827 
12828  try {
12829  if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12830  SWIG_fail;
12831  }
12832  {
12833  if ( _n_dims( args(0) ) > 1 )
12834  {
12835  error( "argument must be a scalar or vector" ); SWIG_fail;
12836  }
12837  temp1 = args(0).matrix_value();
12838  arg1 = &temp1( 0, 0 );
12839  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12840  }
12841  {
12842  if ( _n_dims( args(1) ) > 1 )
12843  {
12844  error( "argument must be a scalar or vector" ); SWIG_fail;
12845  }
12846  temp2 = args(1).matrix_value();
12847  arg2 = &temp2( 0, 0 );
12848  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12849  }
12850  {
12851  if ( _n_dims( args(2) ) > 2 )
12852  {
12853  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12854  }
12855  if ( _dim( args(2), 0 ) != Xlen )
12856  {
12857  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12858  }
12859  if ( _dim( args(2), 1 ) != Ylen )
12860  {
12861  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12862  }
12863  temp3 = args(2).matrix_value();
12864  arg3 = &temp3( 0, 0 );
12865  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12866  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12867  }
12868  ecode6 = SWIG_AsVal_int(args(3), &val6);
12869  if (!SWIG_IsOK(ecode6)) {
12870  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
12871  }
12872  arg6 = static_cast< PLINT >(val6);
12873  {
12874  if ( _n_dims( args(4) ) > 1 )
12875  {
12876  error( "argument must be a scalar or vector" ); SWIG_fail;
12877  }
12878  temp7 = args(4).matrix_value();
12879  arg7 = &temp7( 0, 0 );
12880  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12881  }
12882  ecode9 = SWIG_AsVal_int(args(5), &val9);
12883  if (!SWIG_IsOK(ecode9)) {
12884  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
12885  }
12886  arg9 = static_cast< PLINT >(val9);
12887  {
12888  if ( _n_dims( args(6) ) > 1 )
12889  {
12890  error( "argument must be a scalar or vector" ); SWIG_fail;
12891  }
12892  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12893  arg11 = new PLINT[Alen];
12894  temp10 = args(6).matrix_value();
12895  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12896  }
12897  {
12898  if ( _n_dims( args(7) ) > 1 )
12899  {
12900  error( "argument must be a scalar or vector" ); SWIG_fail;
12901  }
12902  if ( _dim( args(7), 0 ) != Alen )
12903  {
12904  error( "argument vectors must be same length" ); SWIG_fail;
12905  }
12906  temp12 = args(7).matrix_value();
12907  arg12 = new PLINT[Alen];
12908  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12909  }
12910  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);
12911  _outv = octave_value();
12912  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12913  {
12914 
12915  }
12916  {
12917 
12918  }
12919  {
12920 
12921  }
12922  {
12923 
12924  }
12925  {
12926  delete [] arg11;
12927  }
12928  {
12929  delete [] arg12;
12930  }
12931  return _out;
12932  fail:
12933  {
12934 
12935  }
12936  {
12937 
12938  }
12939  {
12940 
12941  }
12942  {
12943 
12944  }
12945  {
12946  delete [] arg11;
12947  }
12948  {
12949  delete [] arg12;
12950  }
12951  return octave_value_list();
12952  }
12953  catch(...) {
12954  {
12955 
12956  }
12957  {
12958 
12959  }
12960  {
12961 
12962  }
12963  {
12964 
12965  }
12966  {
12967  delete [] arg11;
12968  }
12969  {
12970  delete [] arg12;
12971  }
12972  throw;
12973  }
12974 }
12975 
12976 
12978  PLFLT *arg1 = (PLFLT *) 0 ;
12979  PLFLT *arg2 = (PLFLT *) 0 ;
12980  PLFLT *arg3 = (PLFLT *) 0 ;
12981  PLINT arg4 ;
12982  PLINT arg5 ;
12983  PLINT arg6 ;
12984  PLFLT *arg7 = (PLFLT *) 0 ;
12985  PLINT arg8 ;
12986  Matrix temp1 ;
12987  Matrix temp2 ;
12988  Matrix temp3 ;
12989  int val6 ;
12990  int ecode6 = 0 ;
12991  Matrix temp7 ;
12992  octave_value_list _out;
12993  octave_value_list *_outp=&_out;
12994  octave_value _outv;
12995 
12996  try {
12997  if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
12998  SWIG_fail;
12999  }
13000  {
13001  if ( _n_dims( args(0) ) > 1 )
13002  {
13003  error( "argument must be a scalar or vector" ); SWIG_fail;
13004  }
13005  temp1 = args(0).matrix_value();
13006  arg1 = &temp1( 0, 0 );
13007  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13008  }
13009  {
13010  if ( _n_dims( args(1) ) > 1 )
13011  {
13012  error( "argument must be a scalar or vector" ); SWIG_fail;
13013  }
13014  temp2 = args(1).matrix_value();
13015  arg2 = &temp2( 0, 0 );
13016  Ylen = (PLINT) ( _dim( args(1), 0 ) );
13017  }
13018  {
13019  if ( _n_dims( args(2) ) > 2 )
13020  {
13021  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13022  }
13023  if ( _dim( args(2), 0 ) != Xlen )
13024  {
13025  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13026  }
13027  if ( _dim( args(2), 1 ) != Ylen )
13028  {
13029  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13030  }
13031  temp3 = args(2).matrix_value();
13032  arg3 = &temp3( 0, 0 );
13033  arg4 = (PLINT) ( _dim( args(2), 0 ) );
13034  arg5 = (PLINT) ( _dim( args(2), 1 ) );
13035  }
13036  ecode6 = SWIG_AsVal_int(args(3), &val6);
13037  if (!SWIG_IsOK(ecode6)) {
13038  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
13039  }
13040  arg6 = static_cast< PLINT >(val6);
13041  {
13042  if ( _n_dims( args(4) ) > 1 )
13043  {
13044  error( "argument must be a scalar or vector" ); SWIG_fail;
13045  }
13046  temp7 = args(4).matrix_value();
13047  arg7 = &temp7( 0, 0 );
13048  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13049  }
13050  my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
13051  _outv = octave_value();
13052  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13053  {
13054 
13055  }
13056  {
13057 
13058  }
13059  {
13060 
13061  }
13062  {
13063 
13064  }
13065  return _out;
13066  fail:
13067  {
13068 
13069  }
13070  {
13071 
13072  }
13073  {
13074 
13075  }
13076  {
13077 
13078  }
13079  return octave_value_list();
13080  }
13081  catch(...) {
13082  {
13083 
13084  }
13085  {
13086 
13087  }
13088  {
13089 
13090  }
13091  {
13092 
13093  }
13094  throw;
13095  }
13096 }
13097 
13098 
13100  PLFLT *arg1 = (PLFLT *) 0 ;
13101  PLFLT *arg2 = (PLFLT *) 0 ;
13102  PLFLT *arg3 = (PLFLT *) 0 ;
13103  PLINT arg4 ;
13104  PLINT arg5 ;
13105  PLINT arg6 ;
13106  PLFLT *arg7 = (PLFLT *) 0 ;
13107  PLINT arg8 ;
13108  PLINT arg9 ;
13109  PLINT arg10 ;
13110  PLINT *arg11 = (PLINT *) 0 ;
13111  PLINT *arg12 = (PLINT *) 0 ;
13112  Matrix temp1 ;
13113  Matrix temp2 ;
13114  Matrix temp3 ;
13115  int val6 ;
13116  int ecode6 = 0 ;
13117  Matrix temp7 ;
13118  int val9 ;
13119  int ecode9 = 0 ;
13120  Matrix temp10 ;
13121  Matrix temp12 ;
13122  octave_value_list _out;
13123  octave_value_list *_outp=&_out;
13124  octave_value _outv;
13125 
13126  try {
13127  if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
13128  SWIG_fail;
13129  }
13130  {
13131  if ( _n_dims( args(0) ) > 1 )
13132  {
13133  error( "argument must be a scalar or vector" ); SWIG_fail;
13134  }
13135  temp1 = args(0).matrix_value();
13136  arg1 = &temp1( 0, 0 );
13137  Xlen = (PLINT) ( _dim( args(0), 0 ) );
13138  }
13139  {
13140  if ( _n_dims( args(1) ) > 1 )
13141  {
13142  error( "argument must be a scalar or vector" ); SWIG_fail;
13143  }
13144  temp2 = args(1).matrix_value();
13145  arg2 = &temp2( 0, 0 );
13146  Ylen = (PLINT) ( _dim( args(1), 0 ) );
13147  }
13148  {
13149  if ( _n_dims( args(2) ) > 2 )
13150  {
13151  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13152  }
13153  if ( _dim( args(2), 0 ) != Xlen )
13154  {
13155  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
13156  }
13157  if ( _dim( args(2), 1 ) != Ylen )
13158  {
13159  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
13160  }
13161  temp3 = args(2).matrix_value();
13162  arg3 = &temp3( 0, 0 );
13163  arg4 = (PLINT) ( _dim( args(2), 0 ) );
13164  arg5 = (PLINT) ( _dim( args(2), 1 ) );
13165  }
13166  ecode6 = SWIG_AsVal_int(args(3), &val6);
13167  if (!SWIG_IsOK(ecode6)) {
13168  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
13169  }
13170  arg6 = static_cast< PLINT >(val6);
13171  {
13172  if ( _n_dims( args(4) ) > 1 )
13173  {
13174  error( "argument must be a scalar or vector" ); SWIG_fail;
13175  }
13176  temp7 = args(4).matrix_value();
13177  arg7 = &temp7( 0, 0 );
13178  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
13179  }
13180  ecode9 = SWIG_AsVal_int(args(5), &val9);
13181  if (!SWIG_IsOK(ecode9)) {
13182  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
13183  }
13184  arg9 = static_cast< PLINT >(val9);
13185  {
13186  if ( _n_dims( args(6) ) > 1 )
13187  {
13188  error( "argument must be a scalar or vector" ); SWIG_fail;
13189  }
13190  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
13191  arg11 = new PLINT[Alen];
13192  temp10 = args(6).matrix_value();
13193  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
13194  }
13195  {
13196  if ( _n_dims( args(7) ) > 1 )
13197  {
13198  error( "argument must be a scalar or vector" ); SWIG_fail;
13199  }
13200  if ( _dim( args(7), 0 ) != Alen )
13201  {
13202  error( "argument vectors must be same length" ); SWIG_fail;
13203  }
13204  temp12 = args(7).matrix_value();
13205  arg12 = new PLINT[Alen];
13206  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
13207  }
13208  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);
13209  _outv = octave_value();
13210  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13211  {
13212 
13213  }
13214  {
13215 
13216  }
13217  {
13218 
13219  }
13220  {
13221 
13222  }
13223  {
13224  delete [] arg11;
13225  }
13226  {
13227  delete [] arg12;
13228  }
13229  return _out;
13230  fail:
13231  {
13232 
13233  }
13234  {
13235 
13236  }
13237  {
13238 
13239  }
13240  {
13241 
13242  }
13243  {
13244  delete [] arg11;
13245  }
13246  {
13247  delete [] arg12;
13248  }
13249  return octave_value_list();
13250  }
13251  catch(...) {
13252  {
13253 
13254  }
13255  {
13256 
13257  }
13258  {
13259 
13260  }
13261  {
13262 
13263  }
13264  {
13265  delete [] arg11;
13266  }
13267  {
13268  delete [] arg12;
13269  }
13270  throw;
13271  }
13272 }
13273 
13274 
13276  PLFLT *arg1 = (PLFLT *) 0 ;
13277  PLINT arg2 ;
13278  PLINT arg3 ;
13279  PLFLT *arg4 = (PLFLT *) 0 ;
13280  PLFLT arg5 ;
13281  PLFLT arg6 ;
13282  PLFLT arg7 ;
13283  PLFLT arg8 ;
13284  PLFLT arg9 ;
13285  PLFLT arg10 ;
13286  PLINT arg11 ;
13287  PLFLT arg12 ;
13288  PLINT arg13 ;
13289  PLINT arg14 ;
13290  PLINT arg15 ;
13291  PLINT arg16 ;
13292  PLINT arg17 ;
13293  PLBOOL arg18 ;
13294  PLFLT *arg19 = (PLFLT *) 0 ;
13295  Matrix temp1 ;
13296  Matrix temp4 ;
13297  double val5 ;
13298  int ecode5 = 0 ;
13299  double val6 ;
13300  int ecode6 = 0 ;
13301  double val7 ;
13302  int ecode7 = 0 ;
13303  double val8 ;
13304  int ecode8 = 0 ;
13305  double val9 ;
13306  int ecode9 = 0 ;
13307  double val10 ;
13308  int ecode10 = 0 ;
13309  int val11 ;
13310  int ecode11 = 0 ;
13311  double val12 ;
13312  int ecode12 = 0 ;
13313  int val13 ;
13314  int ecode13 = 0 ;
13315  int val14 ;
13316  int ecode14 = 0 ;
13317  int val15 ;
13318  int ecode15 = 0 ;
13319  int val16 ;
13320  int ecode16 = 0 ;
13321  int val17 ;
13322  int ecode17 = 0 ;
13323  int val18 ;
13324  int ecode18 = 0 ;
13325  Matrix temp19 ;
13326  octave_value_list _out;
13327  octave_value_list *_outp=&_out;
13328  octave_value _outv;
13329 
13330  try {
13331  if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
13332  SWIG_fail;
13333  }
13334  {
13335  if ( _n_dims( args(0) ) > 2 )
13336  {
13337  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13338  }
13339  temp1 = args(0).matrix_value();
13340  arg1 = &temp1( 0, 0 );
13341  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13342  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13343  }
13344  {
13345  if ( _n_dims( args(1) ) > 1 )
13346  {
13347  error( "argument must be a scalar or vector" ); SWIG_fail;
13348  }
13349  Alen = (PLINT) ( _dim( args(1), 0 ) );
13350  temp4 = args(1).matrix_value();
13351  arg4 = &temp4( 0, 0 );
13352  }
13353  ecode5 = SWIG_AsVal_double(args(2), &val5);
13354  if (!SWIG_IsOK(ecode5)) {
13355  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
13356  }
13357  arg5 = static_cast< PLFLT >(val5);
13358  ecode6 = SWIG_AsVal_double(args(3), &val6);
13359  if (!SWIG_IsOK(ecode6)) {
13360  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
13361  }
13362  arg6 = static_cast< PLFLT >(val6);
13363  ecode7 = SWIG_AsVal_double(args(4), &val7);
13364  if (!SWIG_IsOK(ecode7)) {
13365  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
13366  }
13367  arg7 = static_cast< PLFLT >(val7);
13368  ecode8 = SWIG_AsVal_double(args(5), &val8);
13369  if (!SWIG_IsOK(ecode8)) {
13370  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
13371  }
13372  arg8 = static_cast< PLFLT >(val8);
13373  ecode9 = SWIG_AsVal_double(args(6), &val9);
13374  if (!SWIG_IsOK(ecode9)) {
13375  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
13376  }
13377  arg9 = static_cast< PLFLT >(val9);
13378  ecode10 = SWIG_AsVal_double(args(7), &val10);
13379  if (!SWIG_IsOK(ecode10)) {
13380  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
13381  }
13382  arg10 = static_cast< PLFLT >(val10);
13383  ecode11 = SWIG_AsVal_int(args(8), &val11);
13384  if (!SWIG_IsOK(ecode11)) {
13385  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13386  }
13387  arg11 = static_cast< PLINT >(val11);
13388  ecode12 = SWIG_AsVal_double(args(9), &val12);
13389  if (!SWIG_IsOK(ecode12)) {
13390  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13391  }
13392  arg12 = static_cast< PLFLT >(val12);
13393  ecode13 = SWIG_AsVal_int(args(10), &val13);
13394  if (!SWIG_IsOK(ecode13)) {
13395  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13396  }
13397  arg13 = static_cast< PLINT >(val13);
13398  ecode14 = SWIG_AsVal_int(args(11), &val14);
13399  if (!SWIG_IsOK(ecode14)) {
13400  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13401  }
13402  arg14 = static_cast< PLINT >(val14);
13403  ecode15 = SWIG_AsVal_int(args(12), &val15);
13404  if (!SWIG_IsOK(ecode15)) {
13405  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13406  }
13407  arg15 = static_cast< PLINT >(val15);
13408  ecode16 = SWIG_AsVal_int(args(13), &val16);
13409  if (!SWIG_IsOK(ecode16)) {
13410  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13411  }
13412  arg16 = static_cast< PLINT >(val16);
13413  ecode17 = SWIG_AsVal_int(args(14), &val17);
13414  if (!SWIG_IsOK(ecode17)) {
13415  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13416  }
13417  arg17 = static_cast< PLINT >(val17);
13418  ecode18 = SWIG_AsVal_int(args(15), &val18);
13419  if (!SWIG_IsOK(ecode18)) {
13420  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13421  }
13422  arg18 = static_cast< PLBOOL >(val18);
13423  {
13424  if ( _n_dims( args(16) ) > 1 )
13425  {
13426  error( "argument must be a scalar or vector" ); SWIG_fail;
13427  }
13428  if ( _dim( args(16), 0 ) != 6 )
13429  {
13430  error( "argument vectors must have length of 6" ); SWIG_fail;
13431  }
13432  temp19 = args(16).matrix_value();
13433  arg19 = &temp19( 0, 0 );
13434  }
13435  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);
13436  _outv = octave_value();
13437  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13438  {
13439 
13440  }
13441  {
13442 
13443  }
13444  {
13445 
13446  }
13447  return _out;
13448  fail:
13449  {
13450 
13451  }
13452  {
13453 
13454  }
13455  {
13456 
13457  }
13458  return octave_value_list();
13459  }
13460  catch(...) {
13461  {
13462 
13463  }
13464  {
13465 
13466  }
13467  {
13468 
13469  }
13470  throw;
13471  }
13472 }
13473 
13474 
13475 SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13476  PLFLT *arg1 = (PLFLT *) 0 ;
13477  PLINT arg2 ;
13478  PLINT arg3 ;
13479  char *arg4 = (char *) 0 ;
13480  PLFLT arg5 ;
13481  PLFLT arg6 ;
13482  PLFLT arg7 ;
13483  PLFLT arg8 ;
13484  PLFLT arg9 ;
13485  PLFLT arg10 ;
13486  PLINT arg11 ;
13487  PLFLT arg12 ;
13488  PLINT arg13 ;
13489  PLINT arg14 ;
13490  PLINT arg15 ;
13491  PLINT arg16 ;
13492  PLINT arg17 ;
13493  PLBOOL arg18 ;
13494  PLFLT *arg19 = (PLFLT *) 0 ;
13495  PLFLT *arg20 = (PLFLT *) 0 ;
13496  Matrix temp1 ;
13497  int res4 ;
13498  char *buf4 = 0 ;
13499  int alloc4 = 0 ;
13500  double val5 ;
13501  int ecode5 = 0 ;
13502  double val6 ;
13503  int ecode6 = 0 ;
13504  double val7 ;
13505  int ecode7 = 0 ;
13506  double val8 ;
13507  int ecode8 = 0 ;
13508  double val9 ;
13509  int ecode9 = 0 ;
13510  double val10 ;
13511  int ecode10 = 0 ;
13512  int val11 ;
13513  int ecode11 = 0 ;
13514  double val12 ;
13515  int ecode12 = 0 ;
13516  int val13 ;
13517  int ecode13 = 0 ;
13518  int val14 ;
13519  int ecode14 = 0 ;
13520  int val15 ;
13521  int ecode15 = 0 ;
13522  int val16 ;
13523  int ecode16 = 0 ;
13524  int val17 ;
13525  int ecode17 = 0 ;
13526  int val18 ;
13527  int ecode18 = 0 ;
13528  Matrix temp19 ;
13529  Matrix temp20 ;
13530  octave_value_list _out;
13531  octave_value_list *_outp=&_out;
13532  octave_value _outv;
13533 
13534  try {
13535  if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13536  SWIG_fail;
13537  }
13538  {
13539  if ( _n_dims( args(0) ) > 2 )
13540  {
13541  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13542  }
13543  temp1 = args(0).matrix_value();
13544  arg1 = &temp1( 0, 0 );
13545  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13546  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13547  }
13548  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13549  if (!SWIG_IsOK(res4)) {
13550  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13551  }
13552  arg4 = reinterpret_cast< char * >(buf4);
13553  ecode5 = SWIG_AsVal_double(args(2), &val5);
13554  if (!SWIG_IsOK(ecode5)) {
13555  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13556  }
13557  arg5 = static_cast< PLFLT >(val5);
13558  ecode6 = SWIG_AsVal_double(args(3), &val6);
13559  if (!SWIG_IsOK(ecode6)) {
13560  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13561  }
13562  arg6 = static_cast< PLFLT >(val6);
13563  ecode7 = SWIG_AsVal_double(args(4), &val7);
13564  if (!SWIG_IsOK(ecode7)) {
13565  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13566  }
13567  arg7 = static_cast< PLFLT >(val7);
13568  ecode8 = SWIG_AsVal_double(args(5), &val8);
13569  if (!SWIG_IsOK(ecode8)) {
13570  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13571  }
13572  arg8 = static_cast< PLFLT >(val8);
13573  ecode9 = SWIG_AsVal_double(args(6), &val9);
13574  if (!SWIG_IsOK(ecode9)) {
13575  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13576  }
13577  arg9 = static_cast< PLFLT >(val9);
13578  ecode10 = SWIG_AsVal_double(args(7), &val10);
13579  if (!SWIG_IsOK(ecode10)) {
13580  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13581  }
13582  arg10 = static_cast< PLFLT >(val10);
13583  ecode11 = SWIG_AsVal_int(args(8), &val11);
13584  if (!SWIG_IsOK(ecode11)) {
13585  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13586  }
13587  arg11 = static_cast< PLINT >(val11);
13588  ecode12 = SWIG_AsVal_double(args(9), &val12);
13589  if (!SWIG_IsOK(ecode12)) {
13590  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13591  }
13592  arg12 = static_cast< PLFLT >(val12);
13593  ecode13 = SWIG_AsVal_int(args(10), &val13);
13594  if (!SWIG_IsOK(ecode13)) {
13595  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13596  }
13597  arg13 = static_cast< PLINT >(val13);
13598  ecode14 = SWIG_AsVal_int(args(11), &val14);
13599  if (!SWIG_IsOK(ecode14)) {
13600  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13601  }
13602  arg14 = static_cast< PLINT >(val14);
13603  ecode15 = SWIG_AsVal_int(args(12), &val15);
13604  if (!SWIG_IsOK(ecode15)) {
13605  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13606  }
13607  arg15 = static_cast< PLINT >(val15);
13608  ecode16 = SWIG_AsVal_int(args(13), &val16);
13609  if (!SWIG_IsOK(ecode16)) {
13610  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13611  }
13612  arg16 = static_cast< PLINT >(val16);
13613  ecode17 = SWIG_AsVal_int(args(14), &val17);
13614  if (!SWIG_IsOK(ecode17)) {
13615  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13616  }
13617  arg17 = static_cast< PLINT >(val17);
13618  ecode18 = SWIG_AsVal_int(args(15), &val18);
13619  if (!SWIG_IsOK(ecode18)) {
13620  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13621  }
13622  arg18 = static_cast< PLBOOL >(val18);
13623  {
13624  if ( _n_dims( args(16) ) > 1 )
13625  {
13626  error( "argument must be a scalar or vector" ); SWIG_fail;
13627  }
13628  if ( _dim( args(16), 0 ) != Xlen )
13629  {
13630  error( "argument vectors must be same length" ); SWIG_fail;
13631  }
13632  temp19 = args(16).matrix_value();
13633  arg19 = &temp19( 0, 0 );
13634  }
13635  {
13636  if ( _n_dims( args(17) ) > 1 )
13637  {
13638  error( "argument must be a scalar or vector" ); SWIG_fail;
13639  }
13640  if ( _dim( args(17), 0 ) != Ylen )
13641  {
13642  error( "argument vectors must be same length" ); SWIG_fail;
13643  }
13644  temp20 = args(17).matrix_value();
13645  arg20 = &temp20( 0, 0 );
13646  }
13647  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);
13648  _outv = octave_value();
13649  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13650  {
13651 
13652  }
13653  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13654  {
13655 
13656  }
13657  {
13658 
13659  }
13660  return _out;
13661  fail:
13662  {
13663 
13664  }
13665  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13666  {
13667 
13668  }
13669  {
13670 
13671  }
13672  return octave_value_list();
13673  }
13674  catch(...) {
13675  {
13676 
13677  }
13678  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13679  {
13680 
13681  }
13682  {
13683 
13684  }
13685  throw;
13686  }
13687 }
13688 
13689 
13690 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13691  PLFLT *arg1 = (PLFLT *) 0 ;
13692  PLINT arg2 ;
13693  PLINT arg3 ;
13694  char *arg4 = (char *) 0 ;
13695  PLFLT arg5 ;
13696  PLFLT arg6 ;
13697  PLFLT arg7 ;
13698  PLFLT arg8 ;
13699  PLFLT arg9 ;
13700  PLFLT arg10 ;
13701  PLINT arg11 ;
13702  PLFLT arg12 ;
13703  PLINT arg13 ;
13704  PLINT arg14 ;
13705  PLINT arg15 ;
13706  PLINT arg16 ;
13707  PLINT arg17 ;
13708  PLBOOL arg18 ;
13709  PLFLT *arg19 = (PLFLT *) 0 ;
13710  PLFLT *arg20 = (PLFLT *) 0 ;
13711  Matrix temp1 ;
13712  int res4 ;
13713  char *buf4 = 0 ;
13714  int alloc4 = 0 ;
13715  double val5 ;
13716  int ecode5 = 0 ;
13717  double val6 ;
13718  int ecode6 = 0 ;
13719  double val7 ;
13720  int ecode7 = 0 ;
13721  double val8 ;
13722  int ecode8 = 0 ;
13723  double val9 ;
13724  int ecode9 = 0 ;
13725  double val10 ;
13726  int ecode10 = 0 ;
13727  int val11 ;
13728  int ecode11 = 0 ;
13729  double val12 ;
13730  int ecode12 = 0 ;
13731  int val13 ;
13732  int ecode13 = 0 ;
13733  int val14 ;
13734  int ecode14 = 0 ;
13735  int val15 ;
13736  int ecode15 = 0 ;
13737  int val16 ;
13738  int ecode16 = 0 ;
13739  int val17 ;
13740  int ecode17 = 0 ;
13741  int val18 ;
13742  int ecode18 = 0 ;
13743  Matrix temp19 ;
13744  Matrix temp20 ;
13745  octave_value_list _out;
13746  octave_value_list *_outp=&_out;
13747  octave_value _outv;
13748 
13749  try {
13750  if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13751  SWIG_fail;
13752  }
13753  {
13754  if ( _n_dims( args(0) ) > 2 )
13755  {
13756  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13757  }
13758  temp1 = args(0).matrix_value();
13759  arg1 = &temp1( 0, 0 );
13760  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13761  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13762  }
13763  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13764  if (!SWIG_IsOK(res4)) {
13765  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13766  }
13767  arg4 = reinterpret_cast< char * >(buf4);
13768  ecode5 = SWIG_AsVal_double(args(2), &val5);
13769  if (!SWIG_IsOK(ecode5)) {
13770  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13771  }
13772  arg5 = static_cast< PLFLT >(val5);
13773  ecode6 = SWIG_AsVal_double(args(3), &val6);
13774  if (!SWIG_IsOK(ecode6)) {
13775  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13776  }
13777  arg6 = static_cast< PLFLT >(val6);
13778  ecode7 = SWIG_AsVal_double(args(4), &val7);
13779  if (!SWIG_IsOK(ecode7)) {
13780  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13781  }
13782  arg7 = static_cast< PLFLT >(val7);
13783  ecode8 = SWIG_AsVal_double(args(5), &val8);
13784  if (!SWIG_IsOK(ecode8)) {
13785  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13786  }
13787  arg8 = static_cast< PLFLT >(val8);
13788  ecode9 = SWIG_AsVal_double(args(6), &val9);
13789  if (!SWIG_IsOK(ecode9)) {
13790  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13791  }
13792  arg9 = static_cast< PLFLT >(val9);
13793  ecode10 = SWIG_AsVal_double(args(7), &val10);
13794  if (!SWIG_IsOK(ecode10)) {
13795  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13796  }
13797  arg10 = static_cast< PLFLT >(val10);
13798  ecode11 = SWIG_AsVal_int(args(8), &val11);
13799  if (!SWIG_IsOK(ecode11)) {
13800  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13801  }
13802  arg11 = static_cast< PLINT >(val11);
13803  ecode12 = SWIG_AsVal_double(args(9), &val12);
13804  if (!SWIG_IsOK(ecode12)) {
13805  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13806  }
13807  arg12 = static_cast< PLFLT >(val12);
13808  ecode13 = SWIG_AsVal_int(args(10), &val13);
13809  if (!SWIG_IsOK(ecode13)) {
13810  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13811  }
13812  arg13 = static_cast< PLINT >(val13);
13813  ecode14 = SWIG_AsVal_int(args(11), &val14);
13814  if (!SWIG_IsOK(ecode14)) {
13815  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13816  }
13817  arg14 = static_cast< PLINT >(val14);
13818  ecode15 = SWIG_AsVal_int(args(12), &val15);
13819  if (!SWIG_IsOK(ecode15)) {
13820  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13821  }
13822  arg15 = static_cast< PLINT >(val15);
13823  ecode16 = SWIG_AsVal_int(args(13), &val16);
13824  if (!SWIG_IsOK(ecode16)) {
13825  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13826  }
13827  arg16 = static_cast< PLINT >(val16);
13828  ecode17 = SWIG_AsVal_int(args(14), &val17);
13829  if (!SWIG_IsOK(ecode17)) {
13830  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13831  }
13832  arg17 = static_cast< PLINT >(val17);
13833  ecode18 = SWIG_AsVal_int(args(15), &val18);
13834  if (!SWIG_IsOK(ecode18)) {
13835  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13836  }
13837  arg18 = static_cast< PLBOOL >(val18);
13838  {
13839  if ( _n_dims( args(16) ) > 2 )
13840  {
13841  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13842  }
13843  temp19 = args(16).matrix_value();
13844  arg19 = &temp19( 0, 0 );
13845  Xlen = (PLINT) ( _dim( args(16), 0 ) );
13846  Ylen = (PLINT) ( _dim( args(16), 1 ) );
13847  }
13848  {
13849  if ( _n_dims( args(17) ) > 2 )
13850  {
13851  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13852  }
13853  temp20 = args(17).matrix_value();
13854  arg20 = &temp20( 0, 0 );
13855  Xlen = (PLINT) ( _dim( args(17), 0 ) );
13856  Ylen = (PLINT) ( _dim( args(17), 1 ) );
13857  }
13858  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);
13859  _outv = octave_value();
13860  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13861  {
13862 
13863  }
13864  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13865  {
13866 
13867  }
13868  {
13869 
13870  }
13871  return _out;
13872  fail:
13873  {
13874 
13875  }
13876  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13877  {
13878 
13879  }
13880  {
13881 
13882  }
13883  return octave_value_list();
13884  }
13885  catch(...) {
13886  {
13887 
13888  }
13889  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13890  {
13891 
13892  }
13893  {
13894 
13895  }
13896  throw;
13897  }
13898 }
13899 
13900 
13902  PLFLT *arg1 = (PLFLT *) 0 ;
13903  PLINT arg2 ;
13904  PLINT arg3 ;
13905  PLFLT arg4 ;
13906  PLFLT arg5 ;
13907  PLFLT arg6 ;
13908  PLFLT arg7 ;
13909  PLFLT *arg8 = (PLFLT *) 0 ;
13910  PLINT arg9 ;
13911  PLINT arg10 ;
13912  PLINT arg11 ;
13913  PLINT arg12 ;
13914  PLBOOL arg13 ;
13915  Matrix temp1 ;
13916  double val4 ;
13917  int ecode4 = 0 ;
13918  double val5 ;
13919  int ecode5 = 0 ;
13920  double val6 ;
13921  int ecode6 = 0 ;
13922  double val7 ;
13923  int ecode7 = 0 ;
13924  Matrix temp8 ;
13925  int val10 ;
13926  int ecode10 = 0 ;
13927  int val11 ;
13928  int ecode11 = 0 ;
13929  int val12 ;
13930  int ecode12 = 0 ;
13931  int val13 ;
13932  int ecode13 = 0 ;
13933  octave_value_list _out;
13934  octave_value_list *_outp=&_out;
13935  octave_value _outv;
13936 
13937  try {
13938  if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
13939  SWIG_fail;
13940  }
13941  {
13942  if ( _n_dims( args(0) ) > 2 )
13943  {
13944  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13945  }
13946  temp1 = args(0).matrix_value();
13947  arg1 = &temp1( 0, 0 );
13948  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13949  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13950  }
13951  ecode4 = SWIG_AsVal_double(args(1), &val4);
13952  if (!SWIG_IsOK(ecode4)) {
13953  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
13954  }
13955  arg4 = static_cast< PLFLT >(val4);
13956  ecode5 = SWIG_AsVal_double(args(2), &val5);
13957  if (!SWIG_IsOK(ecode5)) {
13958  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
13959  }
13960  arg5 = static_cast< PLFLT >(val5);
13961  ecode6 = SWIG_AsVal_double(args(3), &val6);
13962  if (!SWIG_IsOK(ecode6)) {
13963  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
13964  }
13965  arg6 = static_cast< PLFLT >(val6);
13966  ecode7 = SWIG_AsVal_double(args(4), &val7);
13967  if (!SWIG_IsOK(ecode7)) {
13968  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
13969  }
13970  arg7 = static_cast< PLFLT >(val7);
13971  {
13972  if ( _n_dims( args(5) ) > 1 )
13973  {
13974  error( "argument must be a scalar or vector" ); SWIG_fail;
13975  }
13976  temp8 = args(5).matrix_value();
13977  arg8 = &temp8( 0, 0 );
13978  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13979  }
13980  ecode10 = SWIG_AsVal_int(args(6), &val10);
13981  if (!SWIG_IsOK(ecode10)) {
13982  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
13983  }
13984  arg10 = static_cast< PLINT >(val10);
13985  ecode11 = SWIG_AsVal_int(args(7), &val11);
13986  if (!SWIG_IsOK(ecode11)) {
13987  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
13988  }
13989  arg11 = static_cast< PLINT >(val11);
13990  ecode12 = SWIG_AsVal_int(args(8), &val12);
13991  if (!SWIG_IsOK(ecode12)) {
13992  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
13993  }
13994  arg12 = static_cast< PLINT >(val12);
13995  ecode13 = SWIG_AsVal_int(args(9), &val13);
13996  if (!SWIG_IsOK(ecode13)) {
13997  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
13998  }
13999  arg13 = static_cast< PLBOOL >(val13);
14000  my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
14001  _outv = octave_value();
14002  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14003  {
14004 
14005  }
14006  {
14007 
14008  }
14009  return _out;
14010  fail:
14011  {
14012 
14013  }
14014  {
14015 
14016  }
14017  return octave_value_list();
14018  }
14019  catch(...) {
14020  {
14021 
14022  }
14023  {
14024 
14025  }
14026  throw;
14027  }
14028 }
14029 
14030 
14031 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
14032  PLFLT *arg1 = (PLFLT *) 0 ;
14033  PLINT arg2 ;
14034  PLINT arg3 ;
14035  PLFLT arg4 ;
14036  PLFLT arg5 ;
14037  PLFLT arg6 ;
14038  PLFLT arg7 ;
14039  PLFLT *arg8 = (PLFLT *) 0 ;
14040  PLINT arg9 ;
14041  PLINT arg10 ;
14042  PLINT arg11 ;
14043  PLINT arg12 ;
14044  PLBOOL arg13 ;
14045  PLFLT *arg14 = (PLFLT *) 0 ;
14046  Matrix temp1 ;
14047  double val4 ;
14048  int ecode4 = 0 ;
14049  double val5 ;
14050  int ecode5 = 0 ;
14051  double val6 ;
14052  int ecode6 = 0 ;
14053  double val7 ;
14054  int ecode7 = 0 ;
14055  Matrix temp8 ;
14056  int val10 ;
14057  int ecode10 = 0 ;
14058  int val11 ;
14059  int ecode11 = 0 ;
14060  int val12 ;
14061  int ecode12 = 0 ;
14062  int val13 ;
14063  int ecode13 = 0 ;
14064  Matrix temp14 ;
14065  octave_value_list _out;
14066  octave_value_list *_outp=&_out;
14067  octave_value _outv;
14068 
14069  try {
14070  if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
14071  SWIG_fail;
14072  }
14073  {
14074  if ( _n_dims( args(0) ) > 2 )
14075  {
14076  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14077  }
14078  temp1 = args(0).matrix_value();
14079  arg1 = &temp1( 0, 0 );
14080  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14081  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14082  }
14083  ecode4 = SWIG_AsVal_double(args(1), &val4);
14084  if (!SWIG_IsOK(ecode4)) {
14085  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
14086  }
14087  arg4 = static_cast< PLFLT >(val4);
14088  ecode5 = SWIG_AsVal_double(args(2), &val5);
14089  if (!SWIG_IsOK(ecode5)) {
14090  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
14091  }
14092  arg5 = static_cast< PLFLT >(val5);
14093  ecode6 = SWIG_AsVal_double(args(3), &val6);
14094  if (!SWIG_IsOK(ecode6)) {
14095  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
14096  }
14097  arg6 = static_cast< PLFLT >(val6);
14098  ecode7 = SWIG_AsVal_double(args(4), &val7);
14099  if (!SWIG_IsOK(ecode7)) {
14100  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
14101  }
14102  arg7 = static_cast< PLFLT >(val7);
14103  {
14104  if ( _n_dims( args(5) ) > 1 )
14105  {
14106  error( "argument must be a scalar or vector" ); SWIG_fail;
14107  }
14108  temp8 = args(5).matrix_value();
14109  arg8 = &temp8( 0, 0 );
14110  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14111  }
14112  ecode10 = SWIG_AsVal_int(args(6), &val10);
14113  if (!SWIG_IsOK(ecode10)) {
14114  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
14115  }
14116  arg10 = static_cast< PLINT >(val10);
14117  ecode11 = SWIG_AsVal_int(args(7), &val11);
14118  if (!SWIG_IsOK(ecode11)) {
14119  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
14120  }
14121  arg11 = static_cast< PLINT >(val11);
14122  ecode12 = SWIG_AsVal_int(args(8), &val12);
14123  if (!SWIG_IsOK(ecode12)) {
14124  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
14125  }
14126  arg12 = static_cast< PLINT >(val12);
14127  ecode13 = SWIG_AsVal_int(args(9), &val13);
14128  if (!SWIG_IsOK(ecode13)) {
14129  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
14130  }
14131  arg13 = static_cast< PLBOOL >(val13);
14132  {
14133  if ( _n_dims( args(10) ) > 1 )
14134  {
14135  error( "argument must be a scalar or vector" ); SWIG_fail;
14136  }
14137  if ( _dim( args(10), 0 ) != 6 )
14138  {
14139  error( "argument vectors must have length of 6" ); SWIG_fail;
14140  }
14141  temp14 = args(10).matrix_value();
14142  arg14 = &temp14( 0, 0 );
14143  }
14144  my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14145  _outv = octave_value();
14146  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14147  {
14148 
14149  }
14150  {
14151 
14152  }
14153  {
14154 
14155  }
14156  return _out;
14157  fail:
14158  {
14159 
14160  }
14161  {
14162 
14163  }
14164  {
14165 
14166  }
14167  return octave_value_list();
14168  }
14169  catch(...) {
14170  {
14171 
14172  }
14173  {
14174 
14175  }
14176  {
14177 
14178  }
14179  throw;
14180  }
14181 }
14182 
14183 
14184 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
14185  PLFLT *arg1 = (PLFLT *) 0 ;
14186  PLINT arg2 ;
14187  PLINT arg3 ;
14188  PLFLT arg4 ;
14189  PLFLT arg5 ;
14190  PLFLT arg6 ;
14191  PLFLT arg7 ;
14192  PLFLT *arg8 = (PLFLT *) 0 ;
14193  PLINT arg9 ;
14194  PLINT arg10 ;
14195  PLINT arg11 ;
14196  PLINT arg12 ;
14197  PLBOOL arg13 ;
14198  PLFLT *arg14 = (PLFLT *) 0 ;
14199  PLFLT *arg15 = (PLFLT *) 0 ;
14200  Matrix temp1 ;
14201  double val4 ;
14202  int ecode4 = 0 ;
14203  double val5 ;
14204  int ecode5 = 0 ;
14205  double val6 ;
14206  int ecode6 = 0 ;
14207  double val7 ;
14208  int ecode7 = 0 ;
14209  Matrix temp8 ;
14210  int val10 ;
14211  int ecode10 = 0 ;
14212  int val11 ;
14213  int ecode11 = 0 ;
14214  int val12 ;
14215  int ecode12 = 0 ;
14216  int val13 ;
14217  int ecode13 = 0 ;
14218  Matrix temp14 ;
14219  Matrix temp15 ;
14220  octave_value_list _out;
14221  octave_value_list *_outp=&_out;
14222  octave_value _outv;
14223 
14224  try {
14225  if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
14226  SWIG_fail;
14227  }
14228  {
14229  if ( _n_dims( args(0) ) > 2 )
14230  {
14231  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14232  }
14233  temp1 = args(0).matrix_value();
14234  arg1 = &temp1( 0, 0 );
14235  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14236  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14237  }
14238  ecode4 = SWIG_AsVal_double(args(1), &val4);
14239  if (!SWIG_IsOK(ecode4)) {
14240  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
14241  }
14242  arg4 = static_cast< PLFLT >(val4);
14243  ecode5 = SWIG_AsVal_double(args(2), &val5);
14244  if (!SWIG_IsOK(ecode5)) {
14245  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
14246  }
14247  arg5 = static_cast< PLFLT >(val5);
14248  ecode6 = SWIG_AsVal_double(args(3), &val6);
14249  if (!SWIG_IsOK(ecode6)) {
14250  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
14251  }
14252  arg6 = static_cast< PLFLT >(val6);
14253  ecode7 = SWIG_AsVal_double(args(4), &val7);
14254  if (!SWIG_IsOK(ecode7)) {
14255  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
14256  }
14257  arg7 = static_cast< PLFLT >(val7);
14258  {
14259  if ( _n_dims( args(5) ) > 1 )
14260  {
14261  error( "argument must be a scalar or vector" ); SWIG_fail;
14262  }
14263  temp8 = args(5).matrix_value();
14264  arg8 = &temp8( 0, 0 );
14265  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14266  }
14267  ecode10 = SWIG_AsVal_int(args(6), &val10);
14268  if (!SWIG_IsOK(ecode10)) {
14269  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
14270  }
14271  arg10 = static_cast< PLINT >(val10);
14272  ecode11 = SWIG_AsVal_int(args(7), &val11);
14273  if (!SWIG_IsOK(ecode11)) {
14274  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
14275  }
14276  arg11 = static_cast< PLINT >(val11);
14277  ecode12 = SWIG_AsVal_int(args(8), &val12);
14278  if (!SWIG_IsOK(ecode12)) {
14279  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
14280  }
14281  arg12 = static_cast< PLINT >(val12);
14282  ecode13 = SWIG_AsVal_int(args(9), &val13);
14283  if (!SWIG_IsOK(ecode13)) {
14284  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
14285  }
14286  arg13 = static_cast< PLBOOL >(val13);
14287  {
14288  if ( _n_dims( args(10) ) > 1 )
14289  {
14290  error( "argument must be a scalar or vector" ); SWIG_fail;
14291  }
14292  if ( _dim( args(10), 0 ) != Xlen )
14293  {
14294  error( "argument vectors must be same length" ); SWIG_fail;
14295  }
14296  temp14 = args(10).matrix_value();
14297  arg14 = &temp14( 0, 0 );
14298  }
14299  {
14300  if ( _n_dims( args(11) ) > 1 )
14301  {
14302  error( "argument must be a scalar or vector" ); SWIG_fail;
14303  }
14304  if ( _dim( args(11), 0 ) != Ylen )
14305  {
14306  error( "argument vectors must be same length" ); SWIG_fail;
14307  }
14308  temp15 = args(11).matrix_value();
14309  arg15 = &temp15( 0, 0 );
14310  }
14311  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);
14312  _outv = octave_value();
14313  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14314  {
14315 
14316  }
14317  {
14318 
14319  }
14320  {
14321 
14322  }
14323  {
14324 
14325  }
14326  return _out;
14327  fail:
14328  {
14329 
14330  }
14331  {
14332 
14333  }
14334  {
14335 
14336  }
14337  {
14338 
14339  }
14340  return octave_value_list();
14341  }
14342  catch(...) {
14343  {
14344 
14345  }
14346  {
14347 
14348  }
14349  {
14350 
14351  }
14352  {
14353 
14354  }
14355  throw;
14356  }
14357 }
14358 
14359 
14360 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
14361  PLFLT *arg1 = (PLFLT *) 0 ;
14362  PLINT arg2 ;
14363  PLINT arg3 ;
14364  PLFLT arg4 ;
14365  PLFLT arg5 ;
14366  PLFLT arg6 ;
14367  PLFLT arg7 ;
14368  PLFLT *arg8 = (PLFLT *) 0 ;
14369  PLINT arg9 ;
14370  PLINT arg10 ;
14371  PLINT arg11 ;
14372  PLINT arg12 ;
14373  PLBOOL arg13 ;
14374  PLFLT *arg14 = (PLFLT *) 0 ;
14375  PLFLT *arg15 = (PLFLT *) 0 ;
14376  Matrix temp1 ;
14377  double val4 ;
14378  int ecode4 = 0 ;
14379  double val5 ;
14380  int ecode5 = 0 ;
14381  double val6 ;
14382  int ecode6 = 0 ;
14383  double val7 ;
14384  int ecode7 = 0 ;
14385  Matrix temp8 ;
14386  int val10 ;
14387  int ecode10 = 0 ;
14388  int val11 ;
14389  int ecode11 = 0 ;
14390  int val12 ;
14391  int ecode12 = 0 ;
14392  int val13 ;
14393  int ecode13 = 0 ;
14394  Matrix temp14 ;
14395  Matrix temp15 ;
14396  octave_value_list _out;
14397  octave_value_list *_outp=&_out;
14398  octave_value _outv;
14399 
14400  try {
14401  if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
14402  SWIG_fail;
14403  }
14404  {
14405  if ( _n_dims( args(0) ) > 2 )
14406  {
14407  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14408  }
14409  temp1 = args(0).matrix_value();
14410  arg1 = &temp1( 0, 0 );
14411  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14412  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14413  }
14414  ecode4 = SWIG_AsVal_double(args(1), &val4);
14415  if (!SWIG_IsOK(ecode4)) {
14416  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
14417  }
14418  arg4 = static_cast< PLFLT >(val4);
14419  ecode5 = SWIG_AsVal_double(args(2), &val5);
14420  if (!SWIG_IsOK(ecode5)) {
14421  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
14422  }
14423  arg5 = static_cast< PLFLT >(val5);
14424  ecode6 = SWIG_AsVal_double(args(3), &val6);
14425  if (!SWIG_IsOK(ecode6)) {
14426  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
14427  }
14428  arg6 = static_cast< PLFLT >(val6);
14429  ecode7 = SWIG_AsVal_double(args(4), &val7);
14430  if (!SWIG_IsOK(ecode7)) {
14431  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
14432  }
14433  arg7 = static_cast< PLFLT >(val7);
14434  {
14435  if ( _n_dims( args(5) ) > 1 )
14436  {
14437  error( "argument must be a scalar or vector" ); SWIG_fail;
14438  }
14439  temp8 = args(5).matrix_value();
14440  arg8 = &temp8( 0, 0 );
14441  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
14442  }
14443  ecode10 = SWIG_AsVal_int(args(6), &val10);
14444  if (!SWIG_IsOK(ecode10)) {
14445  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
14446  }
14447  arg10 = static_cast< PLINT >(val10);
14448  ecode11 = SWIG_AsVal_int(args(7), &val11);
14449  if (!SWIG_IsOK(ecode11)) {
14450  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
14451  }
14452  arg11 = static_cast< PLINT >(val11);
14453  ecode12 = SWIG_AsVal_int(args(8), &val12);
14454  if (!SWIG_IsOK(ecode12)) {
14455  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
14456  }
14457  arg12 = static_cast< PLINT >(val12);
14458  ecode13 = SWIG_AsVal_int(args(9), &val13);
14459  if (!SWIG_IsOK(ecode13)) {
14460  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
14461  }
14462  arg13 = static_cast< PLBOOL >(val13);
14463  {
14464  if ( _n_dims( args(10) ) > 2 )
14465  {
14466  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14467  }
14468  temp14 = args(10).matrix_value();
14469  arg14 = &temp14( 0, 0 );
14470  Xlen = (PLINT) ( _dim( args(10), 0 ) );
14471  Ylen = (PLINT) ( _dim( args(10), 1 ) );
14472  }
14473  {
14474  if ( _n_dims( args(11) ) > 2 )
14475  {
14476  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14477  }
14478  temp15 = args(11).matrix_value();
14479  arg15 = &temp15( 0, 0 );
14480  Xlen = (PLINT) ( _dim( args(11), 0 ) );
14481  Ylen = (PLINT) ( _dim( args(11), 1 ) );
14482  }
14483  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);
14484  _outv = octave_value();
14485  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14486  {
14487 
14488  }
14489  {
14490 
14491  }
14492  {
14493 
14494  }
14495  {
14496 
14497  }
14498  return _out;
14499  fail:
14500  {
14501 
14502  }
14503  {
14504 
14505  }
14506  {
14507 
14508  }
14509  {
14510 
14511  }
14512  return octave_value_list();
14513  }
14514  catch(...) {
14515  {
14516 
14517  }
14518  {
14519 
14520  }
14521  {
14522 
14523  }
14524  {
14525 
14526  }
14527  throw;
14528  }
14529 }
14530 
14531 
14533  PLFLT *arg1 = (PLFLT *) 0 ;
14534  PLFLT *arg2 = (PLFLT *) 0 ;
14535  PLINT arg3 ;
14536  PLINT arg4 ;
14537  PLFLT arg5 ;
14538  PLFLT *arg6 = (PLFLT *) 0 ;
14539  Matrix temp1 ;
14540  Matrix temp2 ;
14541  double val5 ;
14542  int ecode5 = 0 ;
14543  Matrix temp6 ;
14544  octave_value_list _out;
14545  octave_value_list *_outp=&_out;
14546  octave_value _outv;
14547 
14548  try {
14549  if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14550  SWIG_fail;
14551  }
14552  {
14553  if ( _n_dims( args(0) ) > 2 )
14554  {
14555  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14556  }
14557  temp1 = args(0).matrix_value();
14558  arg1 = &temp1( 0, 0 );
14559  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14560  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14561  }
14562  {
14563  if ( _n_dims( args(1) ) > 2 )
14564  {
14565  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14566  }
14567  if ( _dim( args(1), 0 ) != Xlen )
14568  {
14569  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14570  }
14571  if ( _dim( args(1), 1 ) != Ylen )
14572  {
14573  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14574  }
14575  temp2 = args(1).matrix_value();
14576  arg2 = &temp2( 0, 0 );
14577  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14578  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14579  }
14580  ecode5 = SWIG_AsVal_double(args(2), &val5);
14581  if (!SWIG_IsOK(ecode5)) {
14582  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14583  }
14584  arg5 = static_cast< PLFLT >(val5);
14585  {
14586  if ( _n_dims( args(3) ) > 1 )
14587  {
14588  error( "argument must be a scalar or vector" ); SWIG_fail;
14589  }
14590  if ( _dim( args(3), 0 ) != 6 )
14591  {
14592  error( "argument vectors must have length of 6" ); SWIG_fail;
14593  }
14594  temp6 = args(3).matrix_value();
14595  arg6 = &temp6( 0, 0 );
14596  }
14597  my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14598  _outv = octave_value();
14599  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14600  {
14601 
14602  }
14603  {
14604 
14605  }
14606  {
14607 
14608  }
14609  return _out;
14610  fail:
14611  {
14612 
14613  }
14614  {
14615 
14616  }
14617  {
14618 
14619  }
14620  return octave_value_list();
14621  }
14622  catch(...) {
14623  {
14624 
14625  }
14626  {
14627 
14628  }
14629  {
14630 
14631  }
14632  throw;
14633  }
14634 }
14635 
14636 
14637 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14638  PLFLT *arg1 = (PLFLT *) 0 ;
14639  PLFLT *arg2 = (PLFLT *) 0 ;
14640  PLINT arg3 ;
14641  PLINT arg4 ;
14642  PLFLT arg5 ;
14643  PLFLT *arg6 = (PLFLT *) 0 ;
14644  PLFLT *arg7 = (PLFLT *) 0 ;
14645  Matrix temp1 ;
14646  Matrix temp2 ;
14647  double val5 ;
14648  int ecode5 = 0 ;
14649  Matrix temp6 ;
14650  Matrix temp7 ;
14651  octave_value_list _out;
14652  octave_value_list *_outp=&_out;
14653  octave_value _outv;
14654 
14655  try {
14656  if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14657  SWIG_fail;
14658  }
14659  {
14660  if ( _n_dims( args(0) ) > 2 )
14661  {
14662  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14663  }
14664  temp1 = args(0).matrix_value();
14665  arg1 = &temp1( 0, 0 );
14666  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14667  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14668  }
14669  {
14670  if ( _n_dims( args(1) ) > 2 )
14671  {
14672  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14673  }
14674  if ( _dim( args(1), 0 ) != Xlen )
14675  {
14676  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14677  }
14678  if ( _dim( args(1), 1 ) != Ylen )
14679  {
14680  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14681  }
14682  temp2 = args(1).matrix_value();
14683  arg2 = &temp2( 0, 0 );
14684  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14685  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14686  }
14687  ecode5 = SWIG_AsVal_double(args(2), &val5);
14688  if (!SWIG_IsOK(ecode5)) {
14689  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14690  }
14691  arg5 = static_cast< PLFLT >(val5);
14692  {
14693  if ( _n_dims( args(3) ) > 1 )
14694  {
14695  error( "argument must be a scalar or vector" ); SWIG_fail;
14696  }
14697  if ( _dim( args(3), 0 ) != Xlen )
14698  {
14699  error( "argument vectors must be same length" ); SWIG_fail;
14700  }
14701  temp6 = args(3).matrix_value();
14702  arg6 = &temp6( 0, 0 );
14703  }
14704  {
14705  if ( _n_dims( args(4) ) > 1 )
14706  {
14707  error( "argument must be a scalar or vector" ); SWIG_fail;
14708  }
14709  if ( _dim( args(4), 0 ) != Ylen )
14710  {
14711  error( "argument vectors must be same length" ); SWIG_fail;
14712  }
14713  temp7 = args(4).matrix_value();
14714  arg7 = &temp7( 0, 0 );
14715  }
14716  my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14717  _outv = octave_value();
14718  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14719  {
14720 
14721  }
14722  {
14723 
14724  }
14725  {
14726 
14727  }
14728  {
14729 
14730  }
14731  return _out;
14732  fail:
14733  {
14734 
14735  }
14736  {
14737 
14738  }
14739  {
14740 
14741  }
14742  {
14743 
14744  }
14745  return octave_value_list();
14746  }
14747  catch(...) {
14748  {
14749 
14750  }
14751  {
14752 
14753  }
14754  {
14755 
14756  }
14757  {
14758 
14759  }
14760  throw;
14761  }
14762 }
14763 
14764 
14765 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14766  PLFLT *arg1 = (PLFLT *) 0 ;
14767  PLFLT *arg2 = (PLFLT *) 0 ;
14768  PLINT arg3 ;
14769  PLINT arg4 ;
14770  PLFLT arg5 ;
14771  PLFLT *arg6 = (PLFLT *) 0 ;
14772  PLFLT *arg7 = (PLFLT *) 0 ;
14773  Matrix temp1 ;
14774  Matrix temp2 ;
14775  double val5 ;
14776  int ecode5 = 0 ;
14777  Matrix temp6 ;
14778  Matrix temp7 ;
14779  octave_value_list _out;
14780  octave_value_list *_outp=&_out;
14781  octave_value _outv;
14782 
14783  try {
14784  if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14785  SWIG_fail;
14786  }
14787  {
14788  if ( _n_dims( args(0) ) > 2 )
14789  {
14790  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14791  }
14792  temp1 = args(0).matrix_value();
14793  arg1 = &temp1( 0, 0 );
14794  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14795  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14796  }
14797  {
14798  if ( _n_dims( args(1) ) > 2 )
14799  {
14800  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14801  }
14802  if ( _dim( args(1), 0 ) != Xlen )
14803  {
14804  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14805  }
14806  if ( _dim( args(1), 1 ) != Ylen )
14807  {
14808  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14809  }
14810  temp2 = args(1).matrix_value();
14811  arg2 = &temp2( 0, 0 );
14812  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14813  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14814  }
14815  ecode5 = SWIG_AsVal_double(args(2), &val5);
14816  if (!SWIG_IsOK(ecode5)) {
14817  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14818  }
14819  arg5 = static_cast< PLFLT >(val5);
14820  {
14821  if ( _n_dims( args(3) ) > 2 )
14822  {
14823  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14824  }
14825  temp6 = args(3).matrix_value();
14826  arg6 = &temp6( 0, 0 );
14827  Xlen = (PLINT) ( _dim( args(3), 0 ) );
14828  Ylen = (PLINT) ( _dim( args(3), 1 ) );
14829  }
14830  {
14831  if ( _n_dims( args(4) ) > 2 )
14832  {
14833  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14834  }
14835  temp7 = args(4).matrix_value();
14836  arg7 = &temp7( 0, 0 );
14837  Xlen = (PLINT) ( _dim( args(4), 0 ) );
14838  Ylen = (PLINT) ( _dim( args(4), 1 ) );
14839  }
14840  my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14841  _outv = octave_value();
14842  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14843  {
14844 
14845  }
14846  {
14847 
14848  }
14849  {
14850 
14851  }
14852  {
14853 
14854  }
14855  return _out;
14856  fail:
14857  {
14858 
14859  }
14860  {
14861 
14862  }
14863  {
14864 
14865  }
14866  {
14867 
14868  }
14869  return octave_value_list();
14870  }
14871  catch(...) {
14872  {
14873 
14874  }
14875  {
14876 
14877  }
14878  {
14879 
14880  }
14881  {
14882 
14883  }
14884  throw;
14885  }
14886 }
14887 
14888 
14889 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
14890  PLFLT *arg1 = (PLFLT *) 0 ;
14891  PLINT arg2 ;
14892  PLINT arg3 ;
14893  PLFLT arg4 ;
14894  PLFLT arg5 ;
14895  PLFLT arg6 ;
14896  PLFLT arg7 ;
14897  PLFLT arg8 ;
14898  PLFLT arg9 ;
14899  PLFLT arg10 ;
14900  PLFLT arg11 ;
14901  PLFLT arg12 ;
14902  PLFLT arg13 ;
14903  Matrix temp1 ;
14904  double val4 ;
14905  int ecode4 = 0 ;
14906  double val5 ;
14907  int ecode5 = 0 ;
14908  double val6 ;
14909  int ecode6 = 0 ;
14910  double val7 ;
14911  int ecode7 = 0 ;
14912  double val8 ;
14913  int ecode8 = 0 ;
14914  double val9 ;
14915  int ecode9 = 0 ;
14916  double val10 ;
14917  int ecode10 = 0 ;
14918  double val11 ;
14919  int ecode11 = 0 ;
14920  double val12 ;
14921  int ecode12 = 0 ;
14922  double val13 ;
14923  int ecode13 = 0 ;
14924  octave_value_list _out;
14925  octave_value_list *_outp=&_out;
14926  octave_value _outv;
14927 
14928  try {
14929  if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
14930  SWIG_fail;
14931  }
14932  {
14933  if ( _n_dims( args(0) ) > 2 )
14934  {
14935  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14936  }
14937  temp1 = args(0).matrix_value();
14938  arg1 = &temp1( 0, 0 );
14939  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14940  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14941  }
14942  ecode4 = SWIG_AsVal_double(args(1), &val4);
14943  if (!SWIG_IsOK(ecode4)) {
14944  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
14945  }
14946  arg4 = static_cast< PLFLT >(val4);
14947  ecode5 = SWIG_AsVal_double(args(2), &val5);
14948  if (!SWIG_IsOK(ecode5)) {
14949  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
14950  }
14951  arg5 = static_cast< PLFLT >(val5);
14952  ecode6 = SWIG_AsVal_double(args(3), &val6);
14953  if (!SWIG_IsOK(ecode6)) {
14954  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
14955  }
14956  arg6 = static_cast< PLFLT >(val6);
14957  ecode7 = SWIG_AsVal_double(args(4), &val7);
14958  if (!SWIG_IsOK(ecode7)) {
14959  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
14960  }
14961  arg7 = static_cast< PLFLT >(val7);
14962  ecode8 = SWIG_AsVal_double(args(5), &val8);
14963  if (!SWIG_IsOK(ecode8)) {
14964  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
14965  }
14966  arg8 = static_cast< PLFLT >(val8);
14967  ecode9 = SWIG_AsVal_double(args(6), &val9);
14968  if (!SWIG_IsOK(ecode9)) {
14969  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
14970  }
14971  arg9 = static_cast< PLFLT >(val9);
14972  ecode10 = SWIG_AsVal_double(args(7), &val10);
14973  if (!SWIG_IsOK(ecode10)) {
14974  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
14975  }
14976  arg10 = static_cast< PLFLT >(val10);
14977  ecode11 = SWIG_AsVal_double(args(8), &val11);
14978  if (!SWIG_IsOK(ecode11)) {
14979  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
14980  }
14981  arg11 = static_cast< PLFLT >(val11);
14982  ecode12 = SWIG_AsVal_double(args(9), &val12);
14983  if (!SWIG_IsOK(ecode12)) {
14984  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
14985  }
14986  arg12 = static_cast< PLFLT >(val12);
14987  ecode13 = SWIG_AsVal_double(args(10), &val13);
14988  if (!SWIG_IsOK(ecode13)) {
14989  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
14990  }
14991  arg13 = static_cast< PLFLT >(val13);
14992  my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14993  _outv = octave_value();
14994  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14995  {
14996 
14997  }
14998  return _out;
14999  fail:
15000  {
15001 
15002  }
15003  return octave_value_list();
15004  }
15005  catch(...) {
15006  {
15007 
15008  }
15009  throw;
15010  }
15011 }
15012 
15013 
15015  PLFLT *arg1 = (PLFLT *) 0 ;
15016  PLINT arg2 ;
15017  PLINT arg3 ;
15018  PLFLT arg4 ;
15019  PLFLT arg5 ;
15020  PLFLT arg6 ;
15021  PLFLT arg7 ;
15022  PLFLT arg8 ;
15023  PLFLT arg9 ;
15024  PLFLT arg10 ;
15025  PLFLT arg11 ;
15026  Matrix temp1 ;
15027  double val4 ;
15028  int ecode4 = 0 ;
15029  double val5 ;
15030  int ecode5 = 0 ;
15031  double val6 ;
15032  int ecode6 = 0 ;
15033  double val7 ;
15034  int ecode7 = 0 ;
15035  double val8 ;
15036  int ecode8 = 0 ;
15037  double val9 ;
15038  int ecode9 = 0 ;
15039  double val10 ;
15040  int ecode10 = 0 ;
15041  double val11 ;
15042  int ecode11 = 0 ;
15043  octave_value_list _out;
15044  octave_value_list *_outp=&_out;
15045  octave_value _outv;
15046 
15047  try {
15048  if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
15049  SWIG_fail;
15050  }
15051  {
15052  if ( _n_dims( args(0) ) > 2 )
15053  {
15054  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15055  }
15056  temp1 = args(0).matrix_value();
15057  arg1 = &temp1( 0, 0 );
15058  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15059  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15060  }
15061  ecode4 = SWIG_AsVal_double(args(1), &val4);
15062  if (!SWIG_IsOK(ecode4)) {
15063  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
15064  }
15065  arg4 = static_cast< PLFLT >(val4);
15066  ecode5 = SWIG_AsVal_double(args(2), &val5);
15067  if (!SWIG_IsOK(ecode5)) {
15068  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
15069  }
15070  arg5 = static_cast< PLFLT >(val5);
15071  ecode6 = SWIG_AsVal_double(args(3), &val6);
15072  if (!SWIG_IsOK(ecode6)) {
15073  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
15074  }
15075  arg6 = static_cast< PLFLT >(val6);
15076  ecode7 = SWIG_AsVal_double(args(4), &val7);
15077  if (!SWIG_IsOK(ecode7)) {
15078  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
15079  }
15080  arg7 = static_cast< PLFLT >(val7);
15081  ecode8 = SWIG_AsVal_double(args(5), &val8);
15082  if (!SWIG_IsOK(ecode8)) {
15083  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
15084  }
15085  arg8 = static_cast< PLFLT >(val8);
15086  ecode9 = SWIG_AsVal_double(args(6), &val9);
15087  if (!SWIG_IsOK(ecode9)) {
15088  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
15089  }
15090  arg9 = static_cast< PLFLT >(val9);
15091  ecode10 = SWIG_AsVal_double(args(7), &val10);
15092  if (!SWIG_IsOK(ecode10)) {
15093  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
15094  }
15095  arg10 = static_cast< PLFLT >(val10);
15096  ecode11 = SWIG_AsVal_double(args(8), &val11);
15097  if (!SWIG_IsOK(ecode11)) {
15098  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
15099  }
15100  arg11 = static_cast< PLFLT >(val11);
15101  my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
15102  _outv = octave_value();
15103  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15104  {
15105 
15106  }
15107  return _out;
15108  fail:
15109  {
15110 
15111  }
15112  return octave_value_list();
15113  }
15114  catch(...) {
15115  {
15116 
15117  }
15118  throw;
15119  }
15120 }
15121 
15122 
15123 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
15124  PLFLT *arg1 = (PLFLT *) 0 ;
15125  PLINT arg2 ;
15126  PLINT arg3 ;
15127  PLFLT arg4 ;
15128  PLFLT arg5 ;
15129  PLFLT arg6 ;
15130  PLFLT arg7 ;
15131  PLFLT arg8 ;
15132  PLFLT arg9 ;
15133  PLFLT arg10 ;
15134  PLFLT arg11 ;
15135  PLFLT *arg12 = (PLFLT *) 0 ;
15136  Matrix temp1 ;
15137  double val4 ;
15138  int ecode4 = 0 ;
15139  double val5 ;
15140  int ecode5 = 0 ;
15141  double val6 ;
15142  int ecode6 = 0 ;
15143  double val7 ;
15144  int ecode7 = 0 ;
15145  double val8 ;
15146  int ecode8 = 0 ;
15147  double val9 ;
15148  int ecode9 = 0 ;
15149  double val10 ;
15150  int ecode10 = 0 ;
15151  double val11 ;
15152  int ecode11 = 0 ;
15153  Matrix temp12 ;
15154  octave_value_list _out;
15155  octave_value_list *_outp=&_out;
15156  octave_value _outv;
15157 
15158  try {
15159  if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
15160  SWIG_fail;
15161  }
15162  {
15163  if ( _n_dims( args(0) ) > 2 )
15164  {
15165  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15166  }
15167  temp1 = args(0).matrix_value();
15168  arg1 = &temp1( 0, 0 );
15169  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15170  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15171  }
15172  ecode4 = SWIG_AsVal_double(args(1), &val4);
15173  if (!SWIG_IsOK(ecode4)) {
15174  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
15175  }
15176  arg4 = static_cast< PLFLT >(val4);
15177  ecode5 = SWIG_AsVal_double(args(2), &val5);
15178  if (!SWIG_IsOK(ecode5)) {
15179  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
15180  }
15181  arg5 = static_cast< PLFLT >(val5);
15182  ecode6 = SWIG_AsVal_double(args(3), &val6);
15183  if (!SWIG_IsOK(ecode6)) {
15184  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
15185  }
15186  arg6 = static_cast< PLFLT >(val6);
15187  ecode7 = SWIG_AsVal_double(args(4), &val7);
15188  if (!SWIG_IsOK(ecode7)) {
15189  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
15190  }
15191  arg7 = static_cast< PLFLT >(val7);
15192  ecode8 = SWIG_AsVal_double(args(5), &val8);
15193  if (!SWIG_IsOK(ecode8)) {
15194  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
15195  }
15196  arg8 = static_cast< PLFLT >(val8);
15197  ecode9 = SWIG_AsVal_double(args(6), &val9);
15198  if (!SWIG_IsOK(ecode9)) {
15199  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
15200  }
15201  arg9 = static_cast< PLFLT >(val9);
15202  ecode10 = SWIG_AsVal_double(args(7), &val10);
15203  if (!SWIG_IsOK(ecode10)) {
15204  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
15205  }
15206  arg10 = static_cast< PLFLT >(val10);
15207  ecode11 = SWIG_AsVal_double(args(8), &val11);
15208  if (!SWIG_IsOK(ecode11)) {
15209  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
15210  }
15211  arg11 = static_cast< PLFLT >(val11);
15212  {
15213  if ( _n_dims( args(9) ) > 1 )
15214  {
15215  error( "argument must be a scalar or vector" ); SWIG_fail;
15216  }
15217  if ( _dim( args(9), 0 ) != 6 )
15218  {
15219  error( "argument vectors must have length of 6" ); SWIG_fail;
15220  }
15221  temp12 = args(9).matrix_value();
15222  arg12 = &temp12( 0, 0 );
15223  }
15224  my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15225  _outv = octave_value();
15226  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15227  {
15228 
15229  }
15230  {
15231 
15232  }
15233  return _out;
15234  fail:
15235  {
15236 
15237  }
15238  {
15239 
15240  }
15241  return octave_value_list();
15242  }
15243  catch(...) {
15244  {
15245 
15246  }
15247  {
15248 
15249  }
15250  throw;
15251  }
15252 }
15253 
15254 
15255 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
15256  PLFLT *arg1 = (PLFLT *) 0 ;
15257  PLINT arg2 ;
15258  PLINT arg3 ;
15259  PLFLT arg4 ;
15260  PLFLT arg5 ;
15261  PLFLT arg6 ;
15262  PLFLT arg7 ;
15263  PLFLT arg8 ;
15264  PLFLT arg9 ;
15265  PLFLT arg10 ;
15266  PLFLT arg11 ;
15267  PLFLT *arg12 = (PLFLT *) 0 ;
15268  PLFLT *arg13 = (PLFLT *) 0 ;
15269  Matrix temp1 ;
15270  double val4 ;
15271  int ecode4 = 0 ;
15272  double val5 ;
15273  int ecode5 = 0 ;
15274  double val6 ;
15275  int ecode6 = 0 ;
15276  double val7 ;
15277  int ecode7 = 0 ;
15278  double val8 ;
15279  int ecode8 = 0 ;
15280  double val9 ;
15281  int ecode9 = 0 ;
15282  double val10 ;
15283  int ecode10 = 0 ;
15284  double val11 ;
15285  int ecode11 = 0 ;
15286  Matrix temp12 ;
15287  Matrix temp13 ;
15288  octave_value_list _out;
15289  octave_value_list *_outp=&_out;
15290  octave_value _outv;
15291 
15292  try {
15293  if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
15294  SWIG_fail;
15295  }
15296  {
15297  if ( _n_dims( args(0) ) > 2 )
15298  {
15299  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15300  }
15301  temp1 = args(0).matrix_value();
15302  arg1 = &temp1( 0, 0 );
15303  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15304  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15305  }
15306  ecode4 = SWIG_AsVal_double(args(1), &val4);
15307  if (!SWIG_IsOK(ecode4)) {
15308  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
15309  }
15310  arg4 = static_cast< PLFLT >(val4);
15311  ecode5 = SWIG_AsVal_double(args(2), &val5);
15312  if (!SWIG_IsOK(ecode5)) {
15313  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
15314  }
15315  arg5 = static_cast< PLFLT >(val5);
15316  ecode6 = SWIG_AsVal_double(args(3), &val6);
15317  if (!SWIG_IsOK(ecode6)) {
15318  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
15319  }
15320  arg6 = static_cast< PLFLT >(val6);
15321  ecode7 = SWIG_AsVal_double(args(4), &val7);
15322  if (!SWIG_IsOK(ecode7)) {
15323  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
15324  }
15325  arg7 = static_cast< PLFLT >(val7);
15326  ecode8 = SWIG_AsVal_double(args(5), &val8);
15327  if (!SWIG_IsOK(ecode8)) {
15328  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
15329  }
15330  arg8 = static_cast< PLFLT >(val8);
15331  ecode9 = SWIG_AsVal_double(args(6), &val9);
15332  if (!SWIG_IsOK(ecode9)) {
15333  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
15334  }
15335  arg9 = static_cast< PLFLT >(val9);
15336  ecode10 = SWIG_AsVal_double(args(7), &val10);
15337  if (!SWIG_IsOK(ecode10)) {
15338  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
15339  }
15340  arg10 = static_cast< PLFLT >(val10);
15341  ecode11 = SWIG_AsVal_double(args(8), &val11);
15342  if (!SWIG_IsOK(ecode11)) {
15343  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
15344  }
15345  arg11 = static_cast< PLFLT >(val11);
15346  {
15347  if ( _n_dims( args(9) ) > 1 )
15348  {
15349  error( "argument must be a scalar or vector" ); SWIG_fail;
15350  }
15351  if ( _dim( args(9), 0 ) != Xlen )
15352  {
15353  error( "argument vectors must be same length" ); SWIG_fail;
15354  }
15355  temp12 = args(9).matrix_value();
15356  arg12 = &temp12( 0, 0 );
15357  }
15358  {
15359  if ( _n_dims( args(10) ) > 1 )
15360  {
15361  error( "argument must be a scalar or vector" ); SWIG_fail;
15362  }
15363  if ( _dim( args(10), 0 ) != Ylen )
15364  {
15365  error( "argument vectors must be same length" ); SWIG_fail;
15366  }
15367  temp13 = args(10).matrix_value();
15368  arg13 = &temp13( 0, 0 );
15369  }
15370  my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15371  _outv = octave_value();
15372  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15373  {
15374 
15375  }
15376  {
15377 
15378  }
15379  {
15380 
15381  }
15382  return _out;
15383  fail:
15384  {
15385 
15386  }
15387  {
15388 
15389  }
15390  {
15391 
15392  }
15393  return octave_value_list();
15394  }
15395  catch(...) {
15396  {
15397 
15398  }
15399  {
15400 
15401  }
15402  {
15403 
15404  }
15405  throw;
15406  }
15407 }
15408 
15409 
15410 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
15411  PLFLT *arg1 = (PLFLT *) 0 ;
15412  PLINT arg2 ;
15413  PLINT arg3 ;
15414  PLFLT arg4 ;
15415  PLFLT arg5 ;
15416  PLFLT arg6 ;
15417  PLFLT arg7 ;
15418  PLFLT arg8 ;
15419  PLFLT arg9 ;
15420  PLFLT arg10 ;
15421  PLFLT arg11 ;
15422  PLFLT *arg12 = (PLFLT *) 0 ;
15423  PLFLT *arg13 = (PLFLT *) 0 ;
15424  Matrix temp1 ;
15425  double val4 ;
15426  int ecode4 = 0 ;
15427  double val5 ;
15428  int ecode5 = 0 ;
15429  double val6 ;
15430  int ecode6 = 0 ;
15431  double val7 ;
15432  int ecode7 = 0 ;
15433  double val8 ;
15434  int ecode8 = 0 ;
15435  double val9 ;
15436  int ecode9 = 0 ;
15437  double val10 ;
15438  int ecode10 = 0 ;
15439  double val11 ;
15440  int ecode11 = 0 ;
15441  Matrix temp12 ;
15442  Matrix temp13 ;
15443  octave_value_list _out;
15444  octave_value_list *_outp=&_out;
15445  octave_value _outv;
15446 
15447  try {
15448  if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
15449  SWIG_fail;
15450  }
15451  {
15452  if ( _n_dims( args(0) ) > 2 )
15453  {
15454  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15455  }
15456  temp1 = args(0).matrix_value();
15457  arg1 = &temp1( 0, 0 );
15458  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
15459  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
15460  }
15461  ecode4 = SWIG_AsVal_double(args(1), &val4);
15462  if (!SWIG_IsOK(ecode4)) {
15463  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
15464  }
15465  arg4 = static_cast< PLFLT >(val4);
15466  ecode5 = SWIG_AsVal_double(args(2), &val5);
15467  if (!SWIG_IsOK(ecode5)) {
15468  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
15469  }
15470  arg5 = static_cast< PLFLT >(val5);
15471  ecode6 = SWIG_AsVal_double(args(3), &val6);
15472  if (!SWIG_IsOK(ecode6)) {
15473  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
15474  }
15475  arg6 = static_cast< PLFLT >(val6);
15476  ecode7 = SWIG_AsVal_double(args(4), &val7);
15477  if (!SWIG_IsOK(ecode7)) {
15478  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
15479  }
15480  arg7 = static_cast< PLFLT >(val7);
15481  ecode8 = SWIG_AsVal_double(args(5), &val8);
15482  if (!SWIG_IsOK(ecode8)) {
15483  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
15484  }
15485  arg8 = static_cast< PLFLT >(val8);
15486  ecode9 = SWIG_AsVal_double(args(6), &val9);
15487  if (!SWIG_IsOK(ecode9)) {
15488  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
15489  }
15490  arg9 = static_cast< PLFLT >(val9);
15491  ecode10 = SWIG_AsVal_double(args(7), &val10);
15492  if (!SWIG_IsOK(ecode10)) {
15493  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
15494  }
15495  arg10 = static_cast< PLFLT >(val10);
15496  ecode11 = SWIG_AsVal_double(args(8), &val11);
15497  if (!SWIG_IsOK(ecode11)) {
15498  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
15499  }
15500  arg11 = static_cast< PLFLT >(val11);
15501  {
15502  if ( _n_dims( args(9) ) > 2 )
15503  {
15504  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15505  }
15506  temp12 = args(9).matrix_value();
15507  arg12 = &temp12( 0, 0 );
15508  Xlen = (PLINT) ( _dim( args(9), 0 ) );
15509  Ylen = (PLINT) ( _dim( args(9), 1 ) );
15510  }
15511  {
15512  if ( _n_dims( args(10) ) > 2 )
15513  {
15514  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15515  }
15516  temp13 = args(10).matrix_value();
15517  arg13 = &temp13( 0, 0 );
15518  Xlen = (PLINT) ( _dim( args(10), 0 ) );
15519  Ylen = (PLINT) ( _dim( args(10), 1 ) );
15520  }
15521  my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
15522  _outv = octave_value();
15523  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15524  {
15525 
15526  }
15527  {
15528 
15529  }
15530  {
15531 
15532  }
15533  return _out;
15534  fail:
15535  {
15536 
15537  }
15538  {
15539 
15540  }
15541  {
15542 
15543  }
15544  return octave_value_list();
15545  }
15546  catch(...) {
15547  {
15548 
15549  }
15550  {
15551 
15552  }
15553  {
15554 
15555  }
15556  throw;
15557  }
15558 }
15559 
15560 
15562  PLFLT *arg1 = (PLFLT *) 0 ;
15563  PLFLT *arg2 = (PLFLT *) 0 ;
15564  PLINT arg3 ;
15565  PLINT arg4 ;
15566  PLFLT arg5 ;
15567  PLFLT arg6 ;
15568  PLFLT arg7 ;
15569  PLFLT arg8 ;
15570  PLINT arg9 ;
15571  PLINT arg10 ;
15572  PLINT arg11 ;
15573  PLFLT arg12 ;
15574  PLFLT arg13 ;
15575  PLINT arg14 ;
15576  PLFLT arg15 ;
15577  PLINT arg16 ;
15578  PLINT *arg17 = (PLINT *) 0 ;
15579  char **arg18 = (char **) 0 ;
15580  PLINT arg19 ;
15581  char **arg20 = (char **) 0 ;
15582  PLFLT *arg21 = (PLFLT *) 0 ;
15583  PLINT *arg22 = (PLINT *) 0 ;
15584  PLINT *arg23 = (PLINT *) 0 ;
15585  PLFLT *arg24 = (PLFLT *) 0 ;
15586  PLFLT temp1 ;
15587  int res1 = SWIG_TMPOBJ ;
15588  PLFLT temp2 ;
15589  int res2 = SWIG_TMPOBJ ;
15590  int val3 ;
15591  int ecode3 = 0 ;
15592  int val4 ;
15593  int ecode4 = 0 ;
15594  double val5 ;
15595  int ecode5 = 0 ;
15596  double val6 ;
15597  int ecode6 = 0 ;
15598  double val7 ;
15599  int ecode7 = 0 ;
15600  double val8 ;
15601  int ecode8 = 0 ;
15602  int val9 ;
15603  int ecode9 = 0 ;
15604  int val10 ;
15605  int ecode10 = 0 ;
15606  int val11 ;
15607  int ecode11 = 0 ;
15608  double val12 ;
15609  int ecode12 = 0 ;
15610  double val13 ;
15611  int ecode13 = 0 ;
15612  int val14 ;
15613  int ecode14 = 0 ;
15614  double val15 ;
15615  int ecode15 = 0 ;
15616  Matrix temp16 ;
15617  Matrix temp21 ;
15618  Matrix temp22 ;
15619  Matrix temp23 ;
15620  Matrix temp24 ;
15621  octave_value_list _out;
15622  octave_value_list *_outp=&_out;
15623  octave_value _outv;
15624 
15625  try {
15626  arg1 = &temp1;
15627  arg2 = &temp2;
15628  if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15629  SWIG_fail;
15630  }
15631  ecode3 = SWIG_AsVal_int(args(0), &val3);
15632  if (!SWIG_IsOK(ecode3)) {
15633  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15634  }
15635  arg3 = static_cast< PLINT >(val3);
15636  ecode4 = SWIG_AsVal_int(args(1), &val4);
15637  if (!SWIG_IsOK(ecode4)) {
15638  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15639  }
15640  arg4 = static_cast< PLINT >(val4);
15641  ecode5 = SWIG_AsVal_double(args(2), &val5);
15642  if (!SWIG_IsOK(ecode5)) {
15643  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15644  }
15645  arg5 = static_cast< PLFLT >(val5);
15646  ecode6 = SWIG_AsVal_double(args(3), &val6);
15647  if (!SWIG_IsOK(ecode6)) {
15648  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15649  }
15650  arg6 = static_cast< PLFLT >(val6);
15651  ecode7 = SWIG_AsVal_double(args(4), &val7);
15652  if (!SWIG_IsOK(ecode7)) {
15653  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15654  }
15655  arg7 = static_cast< PLFLT >(val7);
15656  ecode8 = SWIG_AsVal_double(args(5), &val8);
15657  if (!SWIG_IsOK(ecode8)) {
15658  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15659  }
15660  arg8 = static_cast< PLFLT >(val8);
15661  ecode9 = SWIG_AsVal_int(args(6), &val9);
15662  if (!SWIG_IsOK(ecode9)) {
15663  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15664  }
15665  arg9 = static_cast< PLINT >(val9);
15666  ecode10 = SWIG_AsVal_int(args(7), &val10);
15667  if (!SWIG_IsOK(ecode10)) {
15668  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15669  }
15670  arg10 = static_cast< PLINT >(val10);
15671  ecode11 = SWIG_AsVal_int(args(8), &val11);
15672  if (!SWIG_IsOK(ecode11)) {
15673  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15674  }
15675  arg11 = static_cast< PLINT >(val11);
15676  ecode12 = SWIG_AsVal_double(args(9), &val12);
15677  if (!SWIG_IsOK(ecode12)) {
15678  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15679  }
15680  arg12 = static_cast< PLFLT >(val12);
15681  ecode13 = SWIG_AsVal_double(args(10), &val13);
15682  if (!SWIG_IsOK(ecode13)) {
15683  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15684  }
15685  arg13 = static_cast< PLFLT >(val13);
15686  ecode14 = SWIG_AsVal_int(args(11), &val14);
15687  if (!SWIG_IsOK(ecode14)) {
15688  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15689  }
15690  arg14 = static_cast< PLINT >(val14);
15691  ecode15 = SWIG_AsVal_double(args(12), &val15);
15692  if (!SWIG_IsOK(ecode15)) {
15693  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15694  }
15695  arg15 = static_cast< PLFLT >(val15);
15696  {
15697  if ( _n_dims( args(13) ) > 1 )
15698  {
15699  error( "argument must be a scalar or vector" ); SWIG_fail;
15700  }
15701  arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15702  arg17 = new PLINT[Alen];
15703  temp16 = args(13).matrix_value();
15704  _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15705  }
15706  {
15707  charMatrix temp_matrix;
15708  Cell temp_cell;
15709  char *tmp_cstring;
15710  std::string str;
15711  size_t max_length = 0, non_blank_length;
15712  int i, ifcell;
15713  if ( _n_dims( args(14) ) > 2 )
15714  {
15715  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15716  }
15717 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15718  if ( !args(14).isempty() )
15719 #else
15720  if ( !args(14).is_empty() )
15721 #endif
15722  {
15723  if ( _dim( args(14), 0 ) != Alen )
15724  {
15725  error( "first dimension must be same length as previous vector" ); SWIG_fail;
15726  }
15727  arg18 = new char*[Alen];
15728 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15729  ifcell = args(14).iscell();
15730 #else
15731  ifcell = args(14).is_cell();
15732 #endif
15733  if ( ifcell )
15734  {
15735  temp_cell = args(14).cell_value();
15736  }
15737  else
15738  {
15739  temp_matrix = args(14).char_matrix_value();
15740  // Allow one extra space for null termination.
15741  max_length = _dim( args(14), 1 ) + 1;
15742  }
15743 
15744  for ( i = 0; i < Alen; i++ )
15745  {
15746  // Must copy string to "permanent" location because the string
15747  // location corresponding to tmp_cstring gets
15748  // overwritten for each iteration of loop.
15749  if ( ifcell )
15750  {
15751  if ( temp_cell.elem( i ).is_string() )
15752  {
15753  str = temp_cell.elem( i ).string_value();
15754  // leave room for null termination.
15755  max_length = str.size() + 1;
15756  tmp_cstring = (char *) str.c_str();
15757  }
15758  else
15759  {
15760  // Use null string if user attempts to pass a cell array
15761  // with a non-string element (likely an empty element
15762  // since that should be allowed by the PLplot interface
15763  // if that element is going to be unused).
15764  // leave room for null termination.
15765  max_length = 1;
15766  tmp_cstring = (char *) "";
15767  }
15768  }
15769  else
15770  {
15771  str = temp_matrix.row_as_string( i );
15772  tmp_cstring = (char *) str.c_str();
15773  }
15774  arg18[i] = new char[max_length];
15775  strncpy( arg18[i], tmp_cstring, max_length - 1 );
15776  arg18[i][max_length - 1] = '\0';
15777  // All the trailing blank crapola should not be needed for
15778  // string cell arrays.
15779  if ( !ifcell )
15780  {
15781  // remove trailing-blank padding that is used by the
15782  // charMatrix class to insure all strings in a given
15783  // charMatrix instance have the same length.
15784  // This transformation also removes legitimate trailing
15785  // blanks but there is nothing we can do about that
15786  // for the charMatrix class.
15787 
15788  // Look for trailing nulls first (just in case, although that
15789  // shouldn't happen if charMatrix implemented as documented)
15790  // before looking for trailing blanks.
15791  non_blank_length = max_length - 2;
15792  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15793  {
15794  non_blank_length--;
15795  }
15796  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15797  {
15798  non_blank_length--;
15799  }
15800  arg18[i][non_blank_length + 1] = '\0';
15801  }
15802  }
15803  }
15804  else
15805  {
15806  arg18 = NULL;
15807  }
15808  }
15809  {
15810  charMatrix temp_matrix;
15811  Cell temp_cell;
15812  char *tmp_cstring;
15813  std::string str;
15814  size_t max_length = 0, non_blank_length;
15815  int i, ifcell;
15816  if ( _n_dims( args(15) ) > 2 )
15817  {
15818  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15819  }
15820 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15821  if ( !args(15).isempty() )
15822 #else
15823  if ( !args(15).is_empty() )
15824 #endif
15825  {
15826  Alen = _dim( args(15), 0 );
15827  arg19 = Alen;
15828  arg20 = new char*[Alen];
15829 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15830  ifcell = args(15).iscell();
15831 #else
15832  ifcell = args(15).is_cell();
15833 #endif
15834  if ( ifcell )
15835  {
15836  temp_cell = args(15).cell_value();
15837  }
15838  else
15839  {
15840  temp_matrix = args(15).char_matrix_value();
15841  // Allow one extra space for null termination.
15842  max_length = _dim( args(15), 1 ) + 1;
15843  }
15844 
15845  for ( i = 0; i < Alen; i++ )
15846  {
15847  // Must copy string to "permanent" location because the string
15848  // location corresponding to tmp_cstring gets
15849  // overwritten for each iteration of loop.
15850  if ( ifcell )
15851  {
15852  if ( temp_cell.elem( i ).is_string() )
15853  {
15854  str = temp_cell.elem( i ).string_value();
15855  // leave room for null termination.
15856  max_length = str.size() + 1;
15857  tmp_cstring = (char *) str.c_str();
15858  }
15859  else
15860  {
15861  // Use null string if user attempts to pass a cell array
15862  // with a non-string element (likely an empty element
15863  // since that should be allowed by the PLplot interface
15864  // if that element is going to be unused).
15865  // leave room for null termination.
15866  max_length = 1;
15867  tmp_cstring = (char *) "";
15868  }
15869  }
15870  else
15871  {
15872  str = temp_matrix.row_as_string( i );
15873  tmp_cstring = (char *) str.c_str();
15874  }
15875  arg20[i] = new char[max_length];
15876  strncpy( arg20[i], tmp_cstring, max_length - 1 );
15877  arg20[i][max_length - 1] = '\0';
15878  // All the trailing blank crapola should not be needed for
15879  // string cell arrays.
15880  if ( !ifcell )
15881  {
15882  // remove trailing-blank padding that is used by the
15883  // charMatrix class to insure all strings in a given
15884  // charMatrix instance have the same length.
15885  // This transformation also removes legitimate trailing
15886  // blanks but there is nothing we can do about that
15887  // for the charMatrix class.
15888 
15889  // Look for trailing nulls first (just in case, although that
15890  // shouldn't happen if charMatrix implemented as documented)
15891  // before looking for trailing blanks.
15892  non_blank_length = max_length - 2;
15893  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
15894  {
15895  non_blank_length--;
15896  }
15897  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
15898  {
15899  non_blank_length--;
15900  }
15901  arg20[i][non_blank_length + 1] = '\0';
15902  }
15903  }
15904  }
15905  else
15906  {
15907  arg19 = 0;
15908  arg20 = NULL;
15909  }
15910  }
15911  {
15912  if ( _n_dims( args(16) ) > 1 )
15913  {
15914  error( "argument must be a scalar or vector" ); SWIG_fail;
15915  }
15916  if ( _dim( args(16), 0 ) != Alen )
15917  {
15918  error( "argument vectors must be same length" ); SWIG_fail;
15919  }
15920  temp21 = args(16).matrix_value();
15921  arg21 = &temp21( 0, 0 );
15922  }
15923  {
15924  if ( _n_dims( args(17) ) > 1 )
15925  {
15926  error( "argument must be a scalar or vector" ); SWIG_fail;
15927  }
15928  if ( _dim( args(17), 0 ) != Alen )
15929  {
15930  error( "argument vectors must be same length" ); SWIG_fail;
15931  }
15932  temp22 = args(17).matrix_value();
15933  arg22 = new PLINT[Alen];
15934  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
15935  }
15936  {
15937  int i;
15938  if ( _n_dims( args(18) ) > 1 )
15939  {
15940  error( "argument must be a scalar or vector" ); SWIG_fail;
15941  }
15942  if ( _dim( args(18), 0 ) != Alen )
15943  {
15944  error( "argument vectors must be same length" ); SWIG_fail;
15945  }
15946  Xlen = Alen;
15947  temp23 = args(18).matrix_value();
15948  arg23 = new PLINT[Alen];
15949  _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
15950  Ylen = -1;
15951  for ( i = 0; i < Xlen; i++ )
15952  if ( arg23[i] > Ylen )
15953  Ylen = arg23[i];
15954  }
15955  {
15956  if ( _n_dims( args(19) ) > 2 )
15957  {
15958  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15959  }
15960  if ( _dim( args(19), 0 ) != Xlen )
15961  {
15962  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
15963  }
15964  if ( _dim( args(19), 1 ) != Ylen )
15965  {
15966  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
15967  }
15968  temp24 = args(19).matrix_value();
15969  arg24 = &temp24( 0, 0 );
15970  }
15971  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);
15972  _outv = octave_value();
15973  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15974  if (SWIG_IsTmpObj(res1)) {
15975  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15976  } else {
15977  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15978  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15979  }
15980  if (SWIG_IsTmpObj(res2)) {
15981  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15982  } else {
15983  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15984  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15985  }
15986  {
15987  delete [] arg17;
15988  }
15989  {
15990  int i;
15991  if ( arg18 != NULL )
15992  {
15993  for ( i = 0; i < Alen; i++ )
15994  {
15995  delete[] arg18[i];
15996  }
15997  delete[] arg18;
15998  }
15999  }
16000  {
16001  int i;
16002  if ( arg20 != NULL )
16003  {
16004  for ( i = 0; i < Alen; i++ )
16005  {
16006  delete[] arg20[i];
16007  }
16008  delete[] arg20;
16009  }
16010  }
16011  {
16012 
16013  }
16014  {
16015  delete [] arg22;
16016  }
16017  {
16018  delete [] arg23;
16019  }
16020  {
16021 
16022  }
16023  return _out;
16024  fail:
16025  {
16026  delete [] arg17;
16027  }
16028  {
16029  int i;
16030  if ( arg18 != NULL )
16031  {
16032  for ( i = 0; i < Alen; i++ )
16033  {
16034  delete[] arg18[i];
16035  }
16036  delete[] arg18;
16037  }
16038  }
16039  {
16040  int i;
16041  if ( arg20 != NULL )
16042  {
16043  for ( i = 0; i < Alen; i++ )
16044  {
16045  delete[] arg20[i];
16046  }
16047  delete[] arg20;
16048  }
16049  }
16050  {
16051 
16052  }
16053  {
16054  delete [] arg22;
16055  }
16056  {
16057  delete [] arg23;
16058  }
16059  {
16060 
16061  }
16062  return octave_value_list();
16063  }
16064  catch(...) {
16065  {
16066  delete [] arg17;
16067  }
16068  {
16069  int i;
16070  if ( arg18 != NULL )
16071  {
16072  for ( i = 0; i < Alen; i++ )
16073  {
16074  delete[] arg18[i];
16075  }
16076  delete[] arg18;
16077  }
16078  }
16079  {
16080  int i;
16081  if ( arg20 != NULL )
16082  {
16083  for ( i = 0; i < Alen; i++ )
16084  {
16085  delete[] arg20[i];
16086  }
16087  delete[] arg20;
16088  }
16089  }
16090  {
16091 
16092  }
16093  {
16094  delete [] arg22;
16095  }
16096  {
16097  delete [] arg23;
16098  }
16099  {
16100 
16101  }
16102  throw;
16103  }
16104 }
16105 
16106 
16107 SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
16108  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16109  int arg2 ;
16110  void *argp1 = 0 ;
16111  int res1 = 0 ;
16112  int val2 ;
16113  int ecode2 = 0 ;
16114  octave_value_list _out;
16115  octave_value_list *_outp=&_out;
16116  octave_value _outv;
16117 
16118  try {
16119  if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
16120  SWIG_fail;
16121  }
16122  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16123  if (!SWIG_IsOK(res1)) {
16124  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16125  }
16126  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16127  ecode2 = SWIG_AsVal_int(args(1), &val2);
16128  if (!SWIG_IsOK(ecode2)) {
16129  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
16130  }
16131  arg2 = static_cast< int >(val2);
16132  if (arg1) (arg1)->type = arg2;
16133  _outv = octave_value();
16134  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16135  return _out;
16136  fail:
16137  return octave_value_list();
16138  }
16139  catch(...) {
16140  throw;
16141  }
16142 }
16143 
16144 
16145 SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
16146  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16147  void *argp1 = 0 ;
16148  int res1 = 0 ;
16149  octave_value_list _out;
16150  octave_value_list *_outp=&_out;
16151  octave_value _outv;
16152  int result;
16153 
16154  try {
16155  if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
16156  SWIG_fail;
16157  }
16158  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16159  if (!SWIG_IsOK(res1)) {
16160  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16161  }
16162  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16163  result = (int) ((arg1)->type);
16164  _outv = SWIG_From_int(static_cast< int >(result));
16165  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16166  return _out;
16167  fail:
16168  return octave_value_list();
16169  }
16170  catch(...) {
16171  throw;
16172  }
16173 }
16174 
16175 
16176 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
16177  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16178  unsigned int arg2 ;
16179  void *argp1 = 0 ;
16180  int res1 = 0 ;
16181  unsigned int val2 ;
16182  int ecode2 = 0 ;
16183  octave_value_list _out;
16184  octave_value_list *_outp=&_out;
16185  octave_value _outv;
16186 
16187  try {
16188  if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
16189  SWIG_fail;
16190  }
16191  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16192  if (!SWIG_IsOK(res1)) {
16193  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16194  }
16195  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16196  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16197  if (!SWIG_IsOK(ecode2)) {
16198  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
16199  }
16200  arg2 = static_cast< unsigned int >(val2);
16201  if (arg1) (arg1)->state = arg2;
16202  _outv = octave_value();
16203  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16204  return _out;
16205  fail:
16206  return octave_value_list();
16207  }
16208  catch(...) {
16209  throw;
16210  }
16211 }
16212 
16213 
16214 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
16215  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16216  void *argp1 = 0 ;
16217  int res1 = 0 ;
16218  octave_value_list _out;
16219  octave_value_list *_outp=&_out;
16220  octave_value _outv;
16221  unsigned int result;
16222 
16223  try {
16224  if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
16225  SWIG_fail;
16226  }
16227  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16228  if (!SWIG_IsOK(res1)) {
16229  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16230  }
16231  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16232  result = (unsigned int) ((arg1)->state);
16233  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16234  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16235  return _out;
16236  fail:
16237  return octave_value_list();
16238  }
16239  catch(...) {
16240  throw;
16241  }
16242 }
16243 
16244 
16245 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
16246  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16247  unsigned int arg2 ;
16248  void *argp1 = 0 ;
16249  int res1 = 0 ;
16250  unsigned int val2 ;
16251  int ecode2 = 0 ;
16252  octave_value_list _out;
16253  octave_value_list *_outp=&_out;
16254  octave_value _outv;
16255 
16256  try {
16257  if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
16258  SWIG_fail;
16259  }
16260  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16261  if (!SWIG_IsOK(res1)) {
16262  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16263  }
16264  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16265  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16266  if (!SWIG_IsOK(ecode2)) {
16267  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
16268  }
16269  arg2 = static_cast< unsigned int >(val2);
16270  if (arg1) (arg1)->keysym = arg2;
16271  _outv = octave_value();
16272  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16273  return _out;
16274  fail:
16275  return octave_value_list();
16276  }
16277  catch(...) {
16278  throw;
16279  }
16280 }
16281 
16282 
16283 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
16284  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16285  void *argp1 = 0 ;
16286  int res1 = 0 ;
16287  octave_value_list _out;
16288  octave_value_list *_outp=&_out;
16289  octave_value _outv;
16290  unsigned int result;
16291 
16292  try {
16293  if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
16294  SWIG_fail;
16295  }
16296  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16297  if (!SWIG_IsOK(res1)) {
16298  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16299  }
16300  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16301  result = (unsigned int) ((arg1)->keysym);
16302  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16303  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16304  return _out;
16305  fail:
16306  return octave_value_list();
16307  }
16308  catch(...) {
16309  throw;
16310  }
16311 }
16312 
16313 
16314 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
16315  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16316  unsigned int arg2 ;
16317  void *argp1 = 0 ;
16318  int res1 = 0 ;
16319  unsigned int val2 ;
16320  int ecode2 = 0 ;
16321  octave_value_list _out;
16322  octave_value_list *_outp=&_out;
16323  octave_value _outv;
16324 
16325  try {
16326  if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
16327  SWIG_fail;
16328  }
16329  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16330  if (!SWIG_IsOK(res1)) {
16331  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16332  }
16333  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16334  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
16335  if (!SWIG_IsOK(ecode2)) {
16336  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
16337  }
16338  arg2 = static_cast< unsigned int >(val2);
16339  if (arg1) (arg1)->button = arg2;
16340  _outv = octave_value();
16341  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16342  return _out;
16343  fail:
16344  return octave_value_list();
16345  }
16346  catch(...) {
16347  throw;
16348  }
16349 }
16350 
16351 
16352 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
16353  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16354  void *argp1 = 0 ;
16355  int res1 = 0 ;
16356  octave_value_list _out;
16357  octave_value_list *_outp=&_out;
16358  octave_value _outv;
16359  unsigned int result;
16360 
16361  try {
16362  if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
16363  SWIG_fail;
16364  }
16365  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16366  if (!SWIG_IsOK(res1)) {
16367  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16368  }
16369  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16370  result = (unsigned int) ((arg1)->button);
16371  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
16372  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16373  return _out;
16374  fail:
16375  return octave_value_list();
16376  }
16377  catch(...) {
16378  throw;
16379  }
16380 }
16381 
16382 
16383 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
16384  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16385  PLINT arg2 ;
16386  void *argp1 = 0 ;
16387  int res1 = 0 ;
16388  int val2 ;
16389  int ecode2 = 0 ;
16390  octave_value_list _out;
16391  octave_value_list *_outp=&_out;
16392  octave_value _outv;
16393 
16394  try {
16395  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
16396  SWIG_fail;
16397  }
16398  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16399  if (!SWIG_IsOK(res1)) {
16400  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16401  }
16402  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16403  ecode2 = SWIG_AsVal_int(args(1), &val2);
16404  if (!SWIG_IsOK(ecode2)) {
16405  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
16406  }
16407  arg2 = static_cast< PLINT >(val2);
16408  if (arg1) (arg1)->subwindow = arg2;
16409  _outv = octave_value();
16410  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16411  return _out;
16412  fail:
16413  return octave_value_list();
16414  }
16415  catch(...) {
16416  throw;
16417  }
16418 }
16419 
16420 
16421 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
16422  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16423  void *argp1 = 0 ;
16424  int res1 = 0 ;
16425  octave_value_list _out;
16426  octave_value_list *_outp=&_out;
16427  octave_value _outv;
16428  PLINT result;
16429 
16430  try {
16431  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
16432  SWIG_fail;
16433  }
16434  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16435  if (!SWIG_IsOK(res1)) {
16436  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16437  }
16438  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16439  result = (PLINT) ((arg1)->subwindow);
16440  _outv = SWIG_From_int(static_cast< int >(result));
16441  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16442  return _out;
16443  fail:
16444  return octave_value_list();
16445  }
16446  catch(...) {
16447  throw;
16448  }
16449 }
16450 
16451 
16452 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
16453  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16454  char *arg2 ;
16455  void *argp1 = 0 ;
16456  int res1 = 0 ;
16457  char temp2[16] ;
16458  int res2 ;
16459  octave_value_list _out;
16460  octave_value_list *_outp=&_out;
16461  octave_value _outv;
16462 
16463  try {
16464  if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
16465  SWIG_fail;
16466  }
16467  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16468  if (!SWIG_IsOK(res1)) {
16469  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16470  }
16471  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16472  res2 = SWIG_AsCharArray(args(1), temp2, 16);
16473  if (!SWIG_IsOK(res2)) {
16474  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
16475  }
16476  arg2 = reinterpret_cast< char * >(temp2);
16477  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
16478  else memset(arg1->string,0,16*sizeof(char));
16479  _outv = octave_value();
16480  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16481  return _out;
16482  fail:
16483  return octave_value_list();
16484  }
16485  catch(...) {
16486  throw;
16487  }
16488 }
16489 
16490 
16491 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
16492  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16493  void *argp1 = 0 ;
16494  int res1 = 0 ;
16495  octave_value_list _out;
16496  octave_value_list *_outp=&_out;
16497  octave_value _outv;
16498  char *result = 0 ;
16499 
16500  try {
16501  if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
16502  SWIG_fail;
16503  }
16504  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16505  if (!SWIG_IsOK(res1)) {
16506  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16507  }
16508  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16509  result = (char *)(char *) ((arg1)->string);
16510  {
16511  size_t size = SWIG_strnlen(result, 16);
16512 
16513 
16514 
16515  _outv = SWIG_FromCharPtrAndSize(result, size);
16516  }
16517  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16518  return _out;
16519  fail:
16520  return octave_value_list();
16521  }
16522  catch(...) {
16523  throw;
16524  }
16525 }
16526 
16527 
16528 SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
16529  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16530  int arg2 ;
16531  void *argp1 = 0 ;
16532  int res1 = 0 ;
16533  int val2 ;
16534  int ecode2 = 0 ;
16535  octave_value_list _out;
16536  octave_value_list *_outp=&_out;
16537  octave_value _outv;
16538 
16539  try {
16540  if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
16541  SWIG_fail;
16542  }
16543  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16544  if (!SWIG_IsOK(res1)) {
16545  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16546  }
16547  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16548  ecode2 = SWIG_AsVal_int(args(1), &val2);
16549  if (!SWIG_IsOK(ecode2)) {
16550  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
16551  }
16552  arg2 = static_cast< int >(val2);
16553  if (arg1) (arg1)->pX = arg2;
16554  _outv = octave_value();
16555  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16556  return _out;
16557  fail:
16558  return octave_value_list();
16559  }
16560  catch(...) {
16561  throw;
16562  }
16563 }
16564 
16565 
16566 SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
16567  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16568  void *argp1 = 0 ;
16569  int res1 = 0 ;
16570  octave_value_list _out;
16571  octave_value_list *_outp=&_out;
16572  octave_value _outv;
16573  int result;
16574 
16575  try {
16576  if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
16577  SWIG_fail;
16578  }
16579  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16580  if (!SWIG_IsOK(res1)) {
16581  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16582  }
16583  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16584  result = (int) ((arg1)->pX);
16585  _outv = SWIG_From_int(static_cast< int >(result));
16586  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16587  return _out;
16588  fail:
16589  return octave_value_list();
16590  }
16591  catch(...) {
16592  throw;
16593  }
16594 }
16595 
16596 
16597 SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
16598  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16599  int arg2 ;
16600  void *argp1 = 0 ;
16601  int res1 = 0 ;
16602  int val2 ;
16603  int ecode2 = 0 ;
16604  octave_value_list _out;
16605  octave_value_list *_outp=&_out;
16606  octave_value _outv;
16607 
16608  try {
16609  if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
16610  SWIG_fail;
16611  }
16612  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16613  if (!SWIG_IsOK(res1)) {
16614  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16615  }
16616  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16617  ecode2 = SWIG_AsVal_int(args(1), &val2);
16618  if (!SWIG_IsOK(ecode2)) {
16619  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
16620  }
16621  arg2 = static_cast< int >(val2);
16622  if (arg1) (arg1)->pY = arg2;
16623  _outv = octave_value();
16624  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16625  return _out;
16626  fail:
16627  return octave_value_list();
16628  }
16629  catch(...) {
16630  throw;
16631  }
16632 }
16633 
16634 
16635 SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
16636  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16637  void *argp1 = 0 ;
16638  int res1 = 0 ;
16639  octave_value_list _out;
16640  octave_value_list *_outp=&_out;
16641  octave_value _outv;
16642  int result;
16643 
16644  try {
16645  if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
16646  SWIG_fail;
16647  }
16648  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16649  if (!SWIG_IsOK(res1)) {
16650  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16651  }
16652  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16653  result = (int) ((arg1)->pY);
16654  _outv = SWIG_From_int(static_cast< int >(result));
16655  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16656  return _out;
16657  fail:
16658  return octave_value_list();
16659  }
16660  catch(...) {
16661  throw;
16662  }
16663 }
16664 
16665 
16666 SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
16667  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16668  PLFLT arg2 ;
16669  void *argp1 = 0 ;
16670  int res1 = 0 ;
16671  double val2 ;
16672  int ecode2 = 0 ;
16673  octave_value_list _out;
16674  octave_value_list *_outp=&_out;
16675  octave_value _outv;
16676 
16677  try {
16678  if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
16679  SWIG_fail;
16680  }
16681  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16682  if (!SWIG_IsOK(res1)) {
16683  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16684  }
16685  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16686  ecode2 = SWIG_AsVal_double(args(1), &val2);
16687  if (!SWIG_IsOK(ecode2)) {
16688  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
16689  }
16690  arg2 = static_cast< PLFLT >(val2);
16691  if (arg1) (arg1)->dX = arg2;
16692  _outv = octave_value();
16693  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16694  return _out;
16695  fail:
16696  return octave_value_list();
16697  }
16698  catch(...) {
16699  throw;
16700  }
16701 }
16702 
16703 
16704 SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
16705  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16706  void *argp1 = 0 ;
16707  int res1 = 0 ;
16708  octave_value_list _out;
16709  octave_value_list *_outp=&_out;
16710  octave_value _outv;
16711  PLFLT result;
16712 
16713  try {
16714  if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
16715  SWIG_fail;
16716  }
16717  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16718  if (!SWIG_IsOK(res1)) {
16719  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16720  }
16721  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16722  result = (PLFLT) ((arg1)->dX);
16723  _outv = SWIG_From_double(static_cast< double >(result));
16724  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16725  return _out;
16726  fail:
16727  return octave_value_list();
16728  }
16729  catch(...) {
16730  throw;
16731  }
16732 }
16733 
16734 
16735 SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16736  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16737  PLFLT arg2 ;
16738  void *argp1 = 0 ;
16739  int res1 = 0 ;
16740  double val2 ;
16741  int ecode2 = 0 ;
16742  octave_value_list _out;
16743  octave_value_list *_outp=&_out;
16744  octave_value _outv;
16745 
16746  try {
16747  if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16748  SWIG_fail;
16749  }
16750  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16751  if (!SWIG_IsOK(res1)) {
16752  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16753  }
16754  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16755  ecode2 = SWIG_AsVal_double(args(1), &val2);
16756  if (!SWIG_IsOK(ecode2)) {
16757  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16758  }
16759  arg2 = static_cast< PLFLT >(val2);
16760  if (arg1) (arg1)->dY = arg2;
16761  _outv = octave_value();
16762  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16763  return _out;
16764  fail:
16765  return octave_value_list();
16766  }
16767  catch(...) {
16768  throw;
16769  }
16770 }
16771 
16772 
16773 SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16774  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16775  void *argp1 = 0 ;
16776  int res1 = 0 ;
16777  octave_value_list _out;
16778  octave_value_list *_outp=&_out;
16779  octave_value _outv;
16780  PLFLT result;
16781 
16782  try {
16783  if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16784  SWIG_fail;
16785  }
16786  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16787  if (!SWIG_IsOK(res1)) {
16788  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16789  }
16790  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16791  result = (PLFLT) ((arg1)->dY);
16792  _outv = SWIG_From_double(static_cast< double >(result));
16793  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16794  return _out;
16795  fail:
16796  return octave_value_list();
16797  }
16798  catch(...) {
16799  throw;
16800  }
16801 }
16802 
16803 
16804 SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16805  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16806  PLFLT arg2 ;
16807  void *argp1 = 0 ;
16808  int res1 = 0 ;
16809  double val2 ;
16810  int ecode2 = 0 ;
16811  octave_value_list _out;
16812  octave_value_list *_outp=&_out;
16813  octave_value _outv;
16814 
16815  try {
16816  if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16817  SWIG_fail;
16818  }
16819  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16820  if (!SWIG_IsOK(res1)) {
16821  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16822  }
16823  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16824  ecode2 = SWIG_AsVal_double(args(1), &val2);
16825  if (!SWIG_IsOK(ecode2)) {
16826  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16827  }
16828  arg2 = static_cast< PLFLT >(val2);
16829  if (arg1) (arg1)->wX = arg2;
16830  _outv = octave_value();
16831  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16832  return _out;
16833  fail:
16834  return octave_value_list();
16835  }
16836  catch(...) {
16837  throw;
16838  }
16839 }
16840 
16841 
16842 SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16843  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16844  void *argp1 = 0 ;
16845  int res1 = 0 ;
16846  octave_value_list _out;
16847  octave_value_list *_outp=&_out;
16848  octave_value _outv;
16849  PLFLT result;
16850 
16851  try {
16852  if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16853  SWIG_fail;
16854  }
16855  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16856  if (!SWIG_IsOK(res1)) {
16857  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16858  }
16859  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16860  result = (PLFLT) ((arg1)->wX);
16861  _outv = SWIG_From_double(static_cast< double >(result));
16862  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16863  return _out;
16864  fail:
16865  return octave_value_list();
16866  }
16867  catch(...) {
16868  throw;
16869  }
16870 }
16871 
16872 
16873 SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
16874  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16875  PLFLT arg2 ;
16876  void *argp1 = 0 ;
16877  int res1 = 0 ;
16878  double val2 ;
16879  int ecode2 = 0 ;
16880  octave_value_list _out;
16881  octave_value_list *_outp=&_out;
16882  octave_value _outv;
16883 
16884  try {
16885  if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
16886  SWIG_fail;
16887  }
16888  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16889  if (!SWIG_IsOK(res1)) {
16890  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16891  }
16892  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16893  ecode2 = SWIG_AsVal_double(args(1), &val2);
16894  if (!SWIG_IsOK(ecode2)) {
16895  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
16896  }
16897  arg2 = static_cast< PLFLT >(val2);
16898  if (arg1) (arg1)->wY = arg2;
16899  _outv = octave_value();
16900  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16901  return _out;
16902  fail:
16903  return octave_value_list();
16904  }
16905  catch(...) {
16906  throw;
16907  }
16908 }
16909 
16910 
16911 SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
16912  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16913  void *argp1 = 0 ;
16914  int res1 = 0 ;
16915  octave_value_list _out;
16916  octave_value_list *_outp=&_out;
16917  octave_value _outv;
16918  PLFLT result;
16919 
16920  try {
16921  if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
16922  SWIG_fail;
16923  }
16924  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16925  if (!SWIG_IsOK(res1)) {
16926  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16927  }
16928  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16929  result = (PLFLT) ((arg1)->wY);
16930  _outv = SWIG_From_double(static_cast< double >(result));
16931  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16932  return _out;
16933  fail:
16934  return octave_value_list();
16935  }
16936  catch(...) {
16937  throw;
16938  }
16939 }
16940 
16941 
16942 SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
16943  octave_value_list _out;
16944  octave_value_list *_outp=&_out;
16945  octave_value _outv;
16946  PLGraphicsIn *result = 0 ;
16947 
16948  try {
16949  if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
16950  SWIG_fail;
16951  }
16952  result = (PLGraphicsIn *)new PLGraphicsIn();
16954  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16955  return _out;
16956  fail:
16957  return octave_value_list();
16958  }
16959  catch(...) {
16960  throw;
16961  }
16962 }
16963 
16964 
16965 SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
16966  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16967  void *argp1 = 0 ;
16968  int res1 = 0 ;
16969  octave_value_list _out;
16970  octave_value_list *_outp=&_out;
16971  octave_value _outv;
16972 
16973  try {
16974  if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
16975  SWIG_fail;
16976  }
16977  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
16978  if (!SWIG_IsOK(res1)) {
16979  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16980  }
16981  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16982  delete arg1;
16983  _outv = octave_value();
16984  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16985  return _out;
16986  fail:
16987  return octave_value_list();
16988  }
16989  catch(...) {
16990  throw;
16991  }
16992 }
16993 
16994 
17008 {0,0,0,0,0,0}
17009 };
17010 static const char *swig_PLGraphicsIn_base_names[] = {0};
17013 
17015  PLINT arg1 ;
17016  PLINT arg2 ;
17017  int val1 ;
17018  int ecode1 = 0 ;
17019  int val2 ;
17020  int ecode2 = 0 ;
17021  octave_value_list _out;
17022  octave_value_list *_outp=&_out;
17023  octave_value _outv;
17024 
17025  try {
17026  if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
17027  SWIG_fail;
17028  }
17029  ecode1 = SWIG_AsVal_int(args(0), &val1);
17030  if (!SWIG_IsOK(ecode1)) {
17031  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
17032  }
17033  arg1 = static_cast< PLINT >(val1);
17034  ecode2 = SWIG_AsVal_int(args(1), &val2);
17035  if (!SWIG_IsOK(ecode2)) {
17036  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
17037  }
17038  arg2 = static_cast< PLINT >(val2);
17039  pl_setcontlabelformat(arg1,arg2);
17040  _outv = octave_value();
17041  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17042  return _out;
17043  fail:
17044  return octave_value_list();
17045  }
17046  catch(...) {
17047  throw;
17048  }
17049 }
17050 
17051 
17053  PLFLT arg1 ;
17054  PLFLT arg2 ;
17055  PLFLT arg3 ;
17056  PLINT arg4 ;
17057  double val1 ;
17058  int ecode1 = 0 ;
17059  double val2 ;
17060  int ecode2 = 0 ;
17061  double val3 ;
17062  int ecode3 = 0 ;
17063  int val4 ;
17064  int ecode4 = 0 ;
17065  octave_value_list _out;
17066  octave_value_list *_outp=&_out;
17067  octave_value _outv;
17068 
17069  try {
17070  if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
17071  SWIG_fail;
17072  }
17073  ecode1 = SWIG_AsVal_double(args(0), &val1);
17074  if (!SWIG_IsOK(ecode1)) {
17075  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
17076  }
17077  arg1 = static_cast< PLFLT >(val1);
17078  ecode2 = SWIG_AsVal_double(args(1), &val2);
17079  if (!SWIG_IsOK(ecode2)) {
17080  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
17081  }
17082  arg2 = static_cast< PLFLT >(val2);
17083  ecode3 = SWIG_AsVal_double(args(2), &val3);
17084  if (!SWIG_IsOK(ecode3)) {
17085  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
17086  }
17087  arg3 = static_cast< PLFLT >(val3);
17088  ecode4 = SWIG_AsVal_int(args(3), &val4);
17089  if (!SWIG_IsOK(ecode4)) {
17090  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
17091  }
17092  arg4 = static_cast< PLINT >(val4);
17093  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
17094  _outv = octave_value();
17095  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17096  return _out;
17097  fail:
17098  return octave_value_list();
17099  }
17100  catch(...) {
17101  throw;
17102  }
17103 }
17104 
17105 
17107  PLINT arg1 ;
17108  int val1 ;
17109  int ecode1 = 0 ;
17110  octave_value_list _out;
17111  octave_value_list *_outp=&_out;
17112  octave_value _outv;
17113 
17114  try {
17115  if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
17116  SWIG_fail;
17117  }
17118  ecode1 = SWIG_AsVal_int(args(0), &val1);
17119  if (!SWIG_IsOK(ecode1)) {
17120  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
17121  }
17122  arg1 = static_cast< PLINT >(val1);
17123  pladv(arg1);
17124  _outv = octave_value();
17125  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17126  return _out;
17127  fail:
17128  return octave_value_list();
17129  }
17130  catch(...) {
17131  throw;
17132  }
17133 }
17134 
17135 
17137  PLFLT arg1 ;
17138  PLFLT arg2 ;
17139  PLFLT arg3 ;
17140  PLFLT arg4 ;
17141  PLFLT arg5 ;
17142  PLFLT arg6 ;
17143  PLFLT arg7 ;
17144  PLBOOL arg8 ;
17145  double val1 ;
17146  int ecode1 = 0 ;
17147  double val2 ;
17148  int ecode2 = 0 ;
17149  double val3 ;
17150  int ecode3 = 0 ;
17151  double val4 ;
17152  int ecode4 = 0 ;
17153  double val5 ;
17154  int ecode5 = 0 ;
17155  double val6 ;
17156  int ecode6 = 0 ;
17157  double val7 ;
17158  int ecode7 = 0 ;
17159  int val8 ;
17160  int ecode8 = 0 ;
17161  octave_value_list _out;
17162  octave_value_list *_outp=&_out;
17163  octave_value _outv;
17164 
17165  try {
17166  if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
17167  SWIG_fail;
17168  }
17169  ecode1 = SWIG_AsVal_double(args(0), &val1);
17170  if (!SWIG_IsOK(ecode1)) {
17171  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
17172  }
17173  arg1 = static_cast< PLFLT >(val1);
17174  ecode2 = SWIG_AsVal_double(args(1), &val2);
17175  if (!SWIG_IsOK(ecode2)) {
17176  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
17177  }
17178  arg2 = static_cast< PLFLT >(val2);
17179  ecode3 = SWIG_AsVal_double(args(2), &val3);
17180  if (!SWIG_IsOK(ecode3)) {
17181  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
17182  }
17183  arg3 = static_cast< PLFLT >(val3);
17184  ecode4 = SWIG_AsVal_double(args(3), &val4);
17185  if (!SWIG_IsOK(ecode4)) {
17186  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
17187  }
17188  arg4 = static_cast< PLFLT >(val4);
17189  ecode5 = SWIG_AsVal_double(args(4), &val5);
17190  if (!SWIG_IsOK(ecode5)) {
17191  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
17192  }
17193  arg5 = static_cast< PLFLT >(val5);
17194  ecode6 = SWIG_AsVal_double(args(5), &val6);
17195  if (!SWIG_IsOK(ecode6)) {
17196  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
17197  }
17198  arg6 = static_cast< PLFLT >(val6);
17199  ecode7 = SWIG_AsVal_double(args(6), &val7);
17200  if (!SWIG_IsOK(ecode7)) {
17201  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
17202  }
17203  arg7 = static_cast< PLFLT >(val7);
17204  ecode8 = SWIG_AsVal_int(args(7), &val8);
17205  if (!SWIG_IsOK(ecode8)) {
17206  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
17207  }
17208  arg8 = static_cast< PLBOOL >(val8);
17209  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
17210  _outv = octave_value();
17211  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17212  return _out;
17213  fail:
17214  return octave_value_list();
17215  }
17216  catch(...) {
17217  throw;
17218  }
17219 }
17220 
17221 
17223  PLFLT arg1 ;
17224  PLFLT arg2 ;
17225  char *arg3 = (char *) 0 ;
17226  PLFLT arg4 ;
17227  PLINT arg5 ;
17228  char *arg6 = (char *) 0 ;
17229  PLFLT arg7 ;
17230  PLINT arg8 ;
17231  double val1 ;
17232  int ecode1 = 0 ;
17233  double val2 ;
17234  int ecode2 = 0 ;
17235  int res3 ;
17236  char *buf3 = 0 ;
17237  int alloc3 = 0 ;
17238  double val4 ;
17239  int ecode4 = 0 ;
17240  int val5 ;
17241  int ecode5 = 0 ;
17242  int res6 ;
17243  char *buf6 = 0 ;
17244  int alloc6 = 0 ;
17245  double val7 ;
17246  int ecode7 = 0 ;
17247  int val8 ;
17248  int ecode8 = 0 ;
17249  octave_value_list _out;
17250  octave_value_list *_outp=&_out;
17251  octave_value _outv;
17252 
17253  try {
17254  if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
17255  SWIG_fail;
17256  }
17257  ecode1 = SWIG_AsVal_double(args(0), &val1);
17258  if (!SWIG_IsOK(ecode1)) {
17259  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
17260  }
17261  arg1 = static_cast< PLFLT >(val1);
17262  ecode2 = SWIG_AsVal_double(args(1), &val2);
17263  if (!SWIG_IsOK(ecode2)) {
17264  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
17265  }
17266  arg2 = static_cast< PLFLT >(val2);
17267  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
17268  if (!SWIG_IsOK(res3)) {
17269  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
17270  }
17271  arg3 = reinterpret_cast< char * >(buf3);
17272  ecode4 = SWIG_AsVal_double(args(3), &val4);
17273  if (!SWIG_IsOK(ecode4)) {
17274  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
17275  }
17276  arg4 = static_cast< PLFLT >(val4);
17277  ecode5 = SWIG_AsVal_int(args(4), &val5);
17278  if (!SWIG_IsOK(ecode5)) {
17279  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
17280  }
17281  arg5 = static_cast< PLINT >(val5);
17282  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17283  if (!SWIG_IsOK(res6)) {
17284  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
17285  }
17286  arg6 = reinterpret_cast< char * >(buf6);
17287  ecode7 = SWIG_AsVal_double(args(6), &val7);
17288  if (!SWIG_IsOK(ecode7)) {
17289  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
17290  }
17291  arg7 = static_cast< PLFLT >(val7);
17292  ecode8 = SWIG_AsVal_int(args(7), &val8);
17293  if (!SWIG_IsOK(ecode8)) {
17294  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
17295  }
17296  arg8 = static_cast< PLINT >(val8);
17297  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
17298  _outv = octave_value();
17299  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17300  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17301  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17302  return _out;
17303  fail:
17304  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17305  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17306  return octave_value_list();
17307  }
17308  catch(...) {
17309  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
17310  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17311  throw;
17312  }
17313 }
17314 
17315 
17317  PLINT arg1 ;
17318  PLFLT *arg2 = (PLFLT *) 0 ;
17319  PLFLT *arg3 = (PLFLT *) 0 ;
17320  PLINT arg4 ;
17321  Matrix temp1 ;
17322  Matrix temp3 ;
17323  int val4 ;
17324  int ecode4 = 0 ;
17325  octave_value_list _out;
17326  octave_value_list *_outp=&_out;
17327  octave_value _outv;
17328 
17329  try {
17330  if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
17331  SWIG_fail;
17332  }
17333  {
17334  if ( _n_dims( args(0) ) > 1 )
17335  {
17336  error( "argument must be a scalar or vector" ); SWIG_fail;
17337  }
17338  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17339  temp1 = args(0).matrix_value();
17340  arg2 = &temp1( 0, 0 );
17341  }
17342  {
17343  if ( _n_dims( args(1) ) > 1 )
17344  {
17345  error( "argument must be a scalar or vector" ); SWIG_fail;
17346  }
17347  if ( _dim( args(1), 0 ) != Alen )
17348  {
17349  error( "argument vectors must be same length" ); SWIG_fail;
17350  }
17351  temp3 = args(1).matrix_value();
17352  arg3 = &temp3( 0, 0 );
17353  }
17354  ecode4 = SWIG_AsVal_int(args(2), &val4);
17355  if (!SWIG_IsOK(ecode4)) {
17356  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
17357  }
17358  arg4 = static_cast< PLINT >(val4);
17359  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
17360  _outv = octave_value();
17361  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17362  {
17363 
17364  }
17365  {
17366 
17367  }
17368  return _out;
17369  fail:
17370  {
17371 
17372  }
17373  {
17374 
17375  }
17376  return octave_value_list();
17377  }
17378  catch(...) {
17379  {
17380 
17381  }
17382  {
17383 
17384  }
17385  throw;
17386  }
17387 }
17388 
17389 
17391  PLINT *arg1 = (PLINT *) 0 ;
17392  PLINT *arg2 = (PLINT *) 0 ;
17393  PLINT *arg3 = (PLINT *) 0 ;
17394  PLINT *arg4 = (PLINT *) 0 ;
17395  PLINT *arg5 = (PLINT *) 0 ;
17396  PLFLT *arg6 = (PLFLT *) 0 ;
17397  PLFLT arg7 ;
17398  PLINT temp1 ;
17399  int res1 = SWIG_TMPOBJ ;
17400  PLINT temp2 ;
17401  int res2 = SWIG_TMPOBJ ;
17402  PLINT temp3 ;
17403  int res3 = SWIG_TMPOBJ ;
17404  PLINT temp4 ;
17405  int res4 = SWIG_TMPOBJ ;
17406  PLINT temp5 ;
17407  int res5 = SWIG_TMPOBJ ;
17408  PLFLT temp6 ;
17409  int res6 = SWIG_TMPOBJ ;
17410  double val7 ;
17411  int ecode7 = 0 ;
17412  octave_value_list _out;
17413  octave_value_list *_outp=&_out;
17414  octave_value _outv;
17415 
17416  try {
17417  arg1 = &temp1;
17418  arg2 = &temp2;
17419  arg3 = &temp3;
17420  arg4 = &temp4;
17421  arg5 = &temp5;
17422  arg6 = &temp6;
17423  if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
17424  SWIG_fail;
17425  }
17426  ecode7 = SWIG_AsVal_double(args(0), &val7);
17427  if (!SWIG_IsOK(ecode7)) {
17428  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
17429  }
17430  arg7 = static_cast< PLFLT >(val7);
17431  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17432  _outv = octave_value();
17433  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17434  if (SWIG_IsTmpObj(res1)) {
17435  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
17436  } else {
17437  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17438  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
17439  }
17440  if (SWIG_IsTmpObj(res2)) {
17441  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17442  } else {
17443  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17444  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17445  }
17446  if (SWIG_IsTmpObj(res3)) {
17447  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17448  } else {
17449  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17450  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17451  }
17452  if (SWIG_IsTmpObj(res4)) {
17453  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17454  } else {
17455  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17456  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17457  }
17458  if (SWIG_IsTmpObj(res5)) {
17459  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17460  } else {
17461  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17462  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17463  }
17464  if (SWIG_IsTmpObj(res6)) {
17465  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17466  } else {
17467  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17468  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17469  }
17470  return _out;
17471  fail:
17472  return octave_value_list();
17473  }
17474  catch(...) {
17475  throw;
17476  }
17477 }
17478 
17479 
17481  octave_value_list _out;
17482  octave_value_list *_outp=&_out;
17483  octave_value _outv;
17484 
17485  try {
17486  if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
17487  SWIG_fail;
17488  }
17489  plbop();
17490  _outv = octave_value();
17491  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17492  return _out;
17493  fail:
17494  return octave_value_list();
17495  }
17496  catch(...) {
17497  throw;
17498  }
17499 }
17500 
17501 
17503  char *arg1 = (char *) 0 ;
17504  PLFLT arg2 ;
17505  PLINT arg3 ;
17506  char *arg4 = (char *) 0 ;
17507  PLFLT arg5 ;
17508  PLINT arg6 ;
17509  int res1 ;
17510  char *buf1 = 0 ;
17511  int alloc1 = 0 ;
17512  double val2 ;
17513  int ecode2 = 0 ;
17514  int val3 ;
17515  int ecode3 = 0 ;
17516  int res4 ;
17517  char *buf4 = 0 ;
17518  int alloc4 = 0 ;
17519  double val5 ;
17520  int ecode5 = 0 ;
17521  int val6 ;
17522  int ecode6 = 0 ;
17523  octave_value_list _out;
17524  octave_value_list *_outp=&_out;
17525  octave_value _outv;
17526 
17527  try {
17528  if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
17529  SWIG_fail;
17530  }
17531  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17532  if (!SWIG_IsOK(res1)) {
17533  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
17534  }
17535  arg1 = reinterpret_cast< char * >(buf1);
17536  ecode2 = SWIG_AsVal_double(args(1), &val2);
17537  if (!SWIG_IsOK(ecode2)) {
17538  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
17539  }
17540  arg2 = static_cast< PLFLT >(val2);
17541  ecode3 = SWIG_AsVal_int(args(2), &val3);
17542  if (!SWIG_IsOK(ecode3)) {
17543  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
17544  }
17545  arg3 = static_cast< PLINT >(val3);
17546  res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
17547  if (!SWIG_IsOK(res4)) {
17548  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
17549  }
17550  arg4 = reinterpret_cast< char * >(buf4);
17551  ecode5 = SWIG_AsVal_double(args(4), &val5);
17552  if (!SWIG_IsOK(ecode5)) {
17553  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
17554  }
17555  arg5 = static_cast< PLFLT >(val5);
17556  ecode6 = SWIG_AsVal_int(args(5), &val6);
17557  if (!SWIG_IsOK(ecode6)) {
17558  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
17559  }
17560  arg6 = static_cast< PLINT >(val6);
17561  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
17562  _outv = octave_value();
17563  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17564  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17565  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17566  return _out;
17567  fail:
17568  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17569  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17570  return octave_value_list();
17571  }
17572  catch(...) {
17573  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17574  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
17575  throw;
17576  }
17577 }
17578 
17579 
17581  char *arg1 = (char *) 0 ;
17582  char *arg2 = (char *) 0 ;
17583  PLFLT arg3 ;
17584  PLINT arg4 ;
17585  char *arg5 = (char *) 0 ;
17586  char *arg6 = (char *) 0 ;
17587  PLFLT arg7 ;
17588  PLINT arg8 ;
17589  char *arg9 = (char *) 0 ;
17590  char *arg10 = (char *) 0 ;
17591  PLFLT arg11 ;
17592  PLINT arg12 ;
17593  int res1 ;
17594  char *buf1 = 0 ;
17595  int alloc1 = 0 ;
17596  int res2 ;
17597  char *buf2 = 0 ;
17598  int alloc2 = 0 ;
17599  double val3 ;
17600  int ecode3 = 0 ;
17601  int val4 ;
17602  int ecode4 = 0 ;
17603  int res5 ;
17604  char *buf5 = 0 ;
17605  int alloc5 = 0 ;
17606  int res6 ;
17607  char *buf6 = 0 ;
17608  int alloc6 = 0 ;
17609  double val7 ;
17610  int ecode7 = 0 ;
17611  int val8 ;
17612  int ecode8 = 0 ;
17613  int res9 ;
17614  char *buf9 = 0 ;
17615  int alloc9 = 0 ;
17616  int res10 ;
17617  char *buf10 = 0 ;
17618  int alloc10 = 0 ;
17619  double val11 ;
17620  int ecode11 = 0 ;
17621  int val12 ;
17622  int ecode12 = 0 ;
17623  octave_value_list _out;
17624  octave_value_list *_outp=&_out;
17625  octave_value _outv;
17626 
17627  try {
17628  if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
17629  SWIG_fail;
17630  }
17631  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
17632  if (!SWIG_IsOK(res1)) {
17633  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
17634  }
17635  arg1 = reinterpret_cast< char * >(buf1);
17636  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
17637  if (!SWIG_IsOK(res2)) {
17638  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
17639  }
17640  arg2 = reinterpret_cast< char * >(buf2);
17641  ecode3 = SWIG_AsVal_double(args(2), &val3);
17642  if (!SWIG_IsOK(ecode3)) {
17643  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
17644  }
17645  arg3 = static_cast< PLFLT >(val3);
17646  ecode4 = SWIG_AsVal_int(args(3), &val4);
17647  if (!SWIG_IsOK(ecode4)) {
17648  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
17649  }
17650  arg4 = static_cast< PLINT >(val4);
17651  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
17652  if (!SWIG_IsOK(res5)) {
17653  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
17654  }
17655  arg5 = reinterpret_cast< char * >(buf5);
17656  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17657  if (!SWIG_IsOK(res6)) {
17658  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
17659  }
17660  arg6 = reinterpret_cast< char * >(buf6);
17661  ecode7 = SWIG_AsVal_double(args(6), &val7);
17662  if (!SWIG_IsOK(ecode7)) {
17663  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
17664  }
17665  arg7 = static_cast< PLFLT >(val7);
17666  ecode8 = SWIG_AsVal_int(args(7), &val8);
17667  if (!SWIG_IsOK(ecode8)) {
17668  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
17669  }
17670  arg8 = static_cast< PLINT >(val8);
17671  res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
17672  if (!SWIG_IsOK(res9)) {
17673  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
17674  }
17675  arg9 = reinterpret_cast< char * >(buf9);
17676  res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
17677  if (!SWIG_IsOK(res10)) {
17678  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
17679  }
17680  arg10 = reinterpret_cast< char * >(buf10);
17681  ecode11 = SWIG_AsVal_double(args(10), &val11);
17682  if (!SWIG_IsOK(ecode11)) {
17683  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
17684  }
17685  arg11 = static_cast< PLFLT >(val11);
17686  ecode12 = SWIG_AsVal_int(args(11), &val12);
17687  if (!SWIG_IsOK(ecode12)) {
17688  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
17689  }
17690  arg12 = static_cast< PLINT >(val12);
17691  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);
17692  _outv = octave_value();
17693  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17694  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17695  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17696  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17697  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17698  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17699  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17700  return _out;
17701  fail:
17702  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17703  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17704  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17705  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17706  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17707  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17708  return octave_value_list();
17709  }
17710  catch(...) {
17711  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
17712  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
17713  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
17714  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17715  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
17716  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
17717  throw;
17718  }
17719 }
17720 
17721 
17723  PLFLT arg1 ;
17724  PLFLT arg2 ;
17725  PLFLT *arg3 = (PLFLT *) 0 ;
17726  PLFLT *arg4 = (PLFLT *) 0 ;
17727  PLINT *arg5 = (PLINT *) 0 ;
17728  double val1 ;
17729  int ecode1 = 0 ;
17730  double val2 ;
17731  int ecode2 = 0 ;
17732  PLFLT temp3 ;
17733  int res3 = SWIG_TMPOBJ ;
17734  PLFLT temp4 ;
17735  int res4 = SWIG_TMPOBJ ;
17736  PLINT temp5 ;
17737  int res5 = SWIG_TMPOBJ ;
17738  octave_value_list _out;
17739  octave_value_list *_outp=&_out;
17740  octave_value _outv;
17741 
17742  try {
17743  arg3 = &temp3;
17744  arg4 = &temp4;
17745  arg5 = &temp5;
17746  if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
17747  SWIG_fail;
17748  }
17749  ecode1 = SWIG_AsVal_double(args(0), &val1);
17750  if (!SWIG_IsOK(ecode1)) {
17751  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
17752  }
17753  arg1 = static_cast< PLFLT >(val1);
17754  ecode2 = SWIG_AsVal_double(args(1), &val2);
17755  if (!SWIG_IsOK(ecode2)) {
17756  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
17757  }
17758  arg2 = static_cast< PLFLT >(val2);
17759  plcalc_world(arg1,arg2,arg3,arg4,arg5);
17760  _outv = octave_value();
17761  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17762  if (SWIG_IsTmpObj(res3)) {
17763  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
17764  } else {
17765  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17766  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
17767  }
17768  if (SWIG_IsTmpObj(res4)) {
17769  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17770  } else {
17771  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17772  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17773  }
17774  if (SWIG_IsTmpObj(res5)) {
17775  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
17776  } else {
17777  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17778  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
17779  }
17780  return _out;
17781  fail:
17782  return octave_value_list();
17783  }
17784  catch(...) {
17785  throw;
17786  }
17787 }
17788 
17789 
17791  octave_value_list _out;
17792  octave_value_list *_outp=&_out;
17793  octave_value _outv;
17794 
17795  try {
17796  if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
17797  SWIG_fail;
17798  }
17799  plclear();
17800  _outv = octave_value();
17801  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17802  return _out;
17803  fail:
17804  return octave_value_list();
17805  }
17806  catch(...) {
17807  throw;
17808  }
17809 }
17810 
17811 
17813  PLINT arg1 ;
17814  int val1 ;
17815  int ecode1 = 0 ;
17816  octave_value_list _out;
17817  octave_value_list *_outp=&_out;
17818  octave_value _outv;
17819 
17820  try {
17821  if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
17822  SWIG_fail;
17823  }
17824  ecode1 = SWIG_AsVal_int(args(0), &val1);
17825  if (!SWIG_IsOK(ecode1)) {
17826  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
17827  }
17828  arg1 = static_cast< PLINT >(val1);
17829  plcol0(arg1);
17830  _outv = octave_value();
17831  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17832  return _out;
17833  fail:
17834  return octave_value_list();
17835  }
17836  catch(...) {
17837  throw;
17838  }
17839 }
17840 
17841 
17843  PLFLT arg1 ;
17844  double val1 ;
17845  int ecode1 = 0 ;
17846  octave_value_list _out;
17847  octave_value_list *_outp=&_out;
17848  octave_value _outv;
17849 
17850  try {
17851  if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17852  SWIG_fail;
17853  }
17854  ecode1 = SWIG_AsVal_double(args(0), &val1);
17855  if (!SWIG_IsOK(ecode1)) {
17856  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17857  }
17858  arg1 = static_cast< PLFLT >(val1);
17859  plcol1(arg1);
17860  _outv = octave_value();
17861  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17862  return _out;
17863  fail:
17864  return octave_value_list();
17865  }
17866  catch(...) {
17867  throw;
17868  }
17869 }
17870 
17871 
17873  PLFLT arg1 ;
17874  PLFLT arg2 ;
17875  PLFLT arg3 ;
17876  PLINT arg4 ;
17877  PLBOOL arg5 ;
17878  PLINT arg6 ;
17879  PLINT arg7 ;
17880  PLINT arg8 ;
17881  PLINT arg9 ;
17882  PLINT arg10 ;
17883  PLFLT arg11 ;
17884  double val1 ;
17885  int ecode1 = 0 ;
17886  double val2 ;
17887  int ecode2 = 0 ;
17888  double val3 ;
17889  int ecode3 = 0 ;
17890  int val4 ;
17891  int ecode4 = 0 ;
17892  int val5 ;
17893  int ecode5 = 0 ;
17894  int val6 ;
17895  int ecode6 = 0 ;
17896  int val7 ;
17897  int ecode7 = 0 ;
17898  int val8 ;
17899  int ecode8 = 0 ;
17900  int val9 ;
17901  int ecode9 = 0 ;
17902  int val10 ;
17903  int ecode10 = 0 ;
17904  double val11 ;
17905  int ecode11 = 0 ;
17906  octave_value_list _out;
17907  octave_value_list *_outp=&_out;
17908  octave_value _outv;
17909 
17910  try {
17911  if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
17912  SWIG_fail;
17913  }
17914  ecode1 = SWIG_AsVal_double(args(0), &val1);
17915  if (!SWIG_IsOK(ecode1)) {
17916  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
17917  }
17918  arg1 = static_cast< PLFLT >(val1);
17919  ecode2 = SWIG_AsVal_double(args(1), &val2);
17920  if (!SWIG_IsOK(ecode2)) {
17921  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
17922  }
17923  arg2 = static_cast< PLFLT >(val2);
17924  ecode3 = SWIG_AsVal_double(args(2), &val3);
17925  if (!SWIG_IsOK(ecode3)) {
17926  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
17927  }
17928  arg3 = static_cast< PLFLT >(val3);
17929  ecode4 = SWIG_AsVal_int(args(3), &val4);
17930  if (!SWIG_IsOK(ecode4)) {
17931  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
17932  }
17933  arg4 = static_cast< PLINT >(val4);
17934  ecode5 = SWIG_AsVal_int(args(4), &val5);
17935  if (!SWIG_IsOK(ecode5)) {
17936  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
17937  }
17938  arg5 = static_cast< PLBOOL >(val5);
17939  ecode6 = SWIG_AsVal_int(args(5), &val6);
17940  if (!SWIG_IsOK(ecode6)) {
17941  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
17942  }
17943  arg6 = static_cast< PLINT >(val6);
17944  ecode7 = SWIG_AsVal_int(args(6), &val7);
17945  if (!SWIG_IsOK(ecode7)) {
17946  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
17947  }
17948  arg7 = static_cast< PLINT >(val7);
17949  ecode8 = SWIG_AsVal_int(args(7), &val8);
17950  if (!SWIG_IsOK(ecode8)) {
17951  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
17952  }
17953  arg8 = static_cast< PLINT >(val8);
17954  ecode9 = SWIG_AsVal_int(args(8), &val9);
17955  if (!SWIG_IsOK(ecode9)) {
17956  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
17957  }
17958  arg9 = static_cast< PLINT >(val9);
17959  ecode10 = SWIG_AsVal_int(args(9), &val10);
17960  if (!SWIG_IsOK(ecode10)) {
17961  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
17962  }
17963  arg10 = static_cast< PLINT >(val10);
17964  ecode11 = SWIG_AsVal_double(args(10), &val11);
17965  if (!SWIG_IsOK(ecode11)) {
17966  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
17967  }
17968  arg11 = static_cast< PLFLT >(val11);
17969  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
17970  _outv = octave_value();
17971  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17972  return _out;
17973  fail:
17974  return octave_value_list();
17975  }
17976  catch(...) {
17977  throw;
17978  }
17979 }
17980 
17981 
17983  PLINT arg1 ;
17984  PLINT arg2 ;
17985  PLINT arg3 ;
17986  PLINT arg4 ;
17987  PLINT arg5 ;
17988  PLFLT arg6 ;
17989  PLFLT *arg7 = (PLFLT *) 0 ;
17990  int val1 ;
17991  int ecode1 = 0 ;
17992  int val2 ;
17993  int ecode2 = 0 ;
17994  int val3 ;
17995  int ecode3 = 0 ;
17996  int val4 ;
17997  int ecode4 = 0 ;
17998  int val5 ;
17999  int ecode5 = 0 ;
18000  double val6 ;
18001  int ecode6 = 0 ;
18002  PLFLT temp7 ;
18003  int res7 = SWIG_TMPOBJ ;
18004  octave_value_list _out;
18005  octave_value_list *_outp=&_out;
18006  octave_value _outv;
18007 
18008  try {
18009  arg7 = &temp7;
18010  if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
18011  SWIG_fail;
18012  }
18013  ecode1 = SWIG_AsVal_int(args(0), &val1);
18014  if (!SWIG_IsOK(ecode1)) {
18015  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
18016  }
18017  arg1 = static_cast< PLINT >(val1);
18018  ecode2 = SWIG_AsVal_int(args(1), &val2);
18019  if (!SWIG_IsOK(ecode2)) {
18020  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
18021  }
18022  arg2 = static_cast< PLINT >(val2);
18023  ecode3 = SWIG_AsVal_int(args(2), &val3);
18024  if (!SWIG_IsOK(ecode3)) {
18025  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
18026  }
18027  arg3 = static_cast< PLINT >(val3);
18028  ecode4 = SWIG_AsVal_int(args(3), &val4);
18029  if (!SWIG_IsOK(ecode4)) {
18030  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
18031  }
18032  arg4 = static_cast< PLINT >(val4);
18033  ecode5 = SWIG_AsVal_int(args(4), &val5);
18034  if (!SWIG_IsOK(ecode5)) {
18035  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
18036  }
18037  arg5 = static_cast< PLINT >(val5);
18038  ecode6 = SWIG_AsVal_double(args(5), &val6);
18039  if (!SWIG_IsOK(ecode6)) {
18040  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
18041  }
18042  arg6 = static_cast< PLFLT >(val6);
18043  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
18044  _outv = octave_value();
18045  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18046  if (SWIG_IsTmpObj(res7)) {
18047  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
18048  } else {
18049  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18050  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
18051  }
18052  return _out;
18053  fail:
18054  return octave_value_list();
18055  }
18056  catch(...) {
18057  throw;
18058  }
18059 }
18060 
18061 
18063  PLINT arg1 ;
18064  PLBOOL arg2 ;
18065  int val1 ;
18066  int ecode1 = 0 ;
18067  int val2 ;
18068  int ecode2 = 0 ;
18069  octave_value_list _out;
18070  octave_value_list *_outp=&_out;
18071  octave_value _outv;
18072 
18073  try {
18074  if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
18075  SWIG_fail;
18076  }
18077  ecode1 = SWIG_AsVal_int(args(0), &val1);
18078  if (!SWIG_IsOK(ecode1)) {
18079  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
18080  }
18081  arg1 = static_cast< PLINT >(val1);
18082  ecode2 = SWIG_AsVal_int(args(1), &val2);
18083  if (!SWIG_IsOK(ecode2)) {
18084  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
18085  }
18086  arg2 = static_cast< PLBOOL >(val2);
18087  plcpstrm(arg1,arg2);
18088  _outv = octave_value();
18089  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18090  return _out;
18091  fail:
18092  return octave_value_list();
18093  }
18094  catch(...) {
18095  throw;
18096  }
18097 }
18098 
18099 
18101  octave_value_list _out;
18102  octave_value_list *_outp=&_out;
18103  octave_value _outv;
18104 
18105  try {
18106  if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
18107  SWIG_fail;
18108  }
18109  plend();
18110  _outv = octave_value();
18111  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18112  return _out;
18113  fail:
18114  return octave_value_list();
18115  }
18116  catch(...) {
18117  throw;
18118  }
18119 }
18120 
18121 
18123  octave_value_list _out;
18124  octave_value_list *_outp=&_out;
18125  octave_value _outv;
18126 
18127  try {
18128  if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
18129  SWIG_fail;
18130  }
18131  plend1();
18132  _outv = octave_value();
18133  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18134  return _out;
18135  fail:
18136  return octave_value_list();
18137  }
18138  catch(...) {
18139  throw;
18140  }
18141 }
18142 
18143 
18145  PLFLT arg1 ;
18146  PLFLT arg2 ;
18147  PLFLT arg3 ;
18148  PLFLT arg4 ;
18149  PLINT arg5 ;
18150  PLINT arg6 ;
18151  double val1 ;
18152  int ecode1 = 0 ;
18153  double val2 ;
18154  int ecode2 = 0 ;
18155  double val3 ;
18156  int ecode3 = 0 ;
18157  double val4 ;
18158  int ecode4 = 0 ;
18159  int val5 ;
18160  int ecode5 = 0 ;
18161  int val6 ;
18162  int ecode6 = 0 ;
18163  octave_value_list _out;
18164  octave_value_list *_outp=&_out;
18165  octave_value _outv;
18166 
18167  try {
18168  if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
18169  SWIG_fail;
18170  }
18171  ecode1 = SWIG_AsVal_double(args(0), &val1);
18172  if (!SWIG_IsOK(ecode1)) {
18173  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
18174  }
18175  arg1 = static_cast< PLFLT >(val1);
18176  ecode2 = SWIG_AsVal_double(args(1), &val2);
18177  if (!SWIG_IsOK(ecode2)) {
18178  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
18179  }
18180  arg2 = static_cast< PLFLT >(val2);
18181  ecode3 = SWIG_AsVal_double(args(2), &val3);
18182  if (!SWIG_IsOK(ecode3)) {
18183  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
18184  }
18185  arg3 = static_cast< PLFLT >(val3);
18186  ecode4 = SWIG_AsVal_double(args(3), &val4);
18187  if (!SWIG_IsOK(ecode4)) {
18188  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
18189  }
18190  arg4 = static_cast< PLFLT >(val4);
18191  ecode5 = SWIG_AsVal_int(args(4), &val5);
18192  if (!SWIG_IsOK(ecode5)) {
18193  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
18194  }
18195  arg5 = static_cast< PLINT >(val5);
18196  ecode6 = SWIG_AsVal_int(args(5), &val6);
18197  if (!SWIG_IsOK(ecode6)) {
18198  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
18199  }
18200  arg6 = static_cast< PLINT >(val6);
18201  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
18202  _outv = octave_value();
18203  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18204  return _out;
18205  fail:
18206  return octave_value_list();
18207  }
18208  catch(...) {
18209  throw;
18210  }
18211 }
18212 
18213 
18215  PLFLT arg1 ;
18216  PLFLT arg2 ;
18217  PLFLT arg3 ;
18218  PLFLT arg4 ;
18219  PLINT arg5 ;
18220  PLINT arg6 ;
18221  double val1 ;
18222  int ecode1 = 0 ;
18223  double val2 ;
18224  int ecode2 = 0 ;
18225  double val3 ;
18226  int ecode3 = 0 ;
18227  double val4 ;
18228  int ecode4 = 0 ;
18229  int val5 ;
18230  int ecode5 = 0 ;
18231  int val6 ;
18232  int ecode6 = 0 ;
18233  octave_value_list _out;
18234  octave_value_list *_outp=&_out;
18235  octave_value _outv;
18236 
18237  try {
18238  if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
18239  SWIG_fail;
18240  }
18241  ecode1 = SWIG_AsVal_double(args(0), &val1);
18242  if (!SWIG_IsOK(ecode1)) {
18243  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
18244  }
18245  arg1 = static_cast< PLFLT >(val1);
18246  ecode2 = SWIG_AsVal_double(args(1), &val2);
18247  if (!SWIG_IsOK(ecode2)) {
18248  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
18249  }
18250  arg2 = static_cast< PLFLT >(val2);
18251  ecode3 = SWIG_AsVal_double(args(2), &val3);
18252  if (!SWIG_IsOK(ecode3)) {
18253  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
18254  }
18255  arg3 = static_cast< PLFLT >(val3);
18256  ecode4 = SWIG_AsVal_double(args(3), &val4);
18257  if (!SWIG_IsOK(ecode4)) {
18258  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
18259  }
18260  arg4 = static_cast< PLFLT >(val4);
18261  ecode5 = SWIG_AsVal_int(args(4), &val5);
18262  if (!SWIG_IsOK(ecode5)) {
18263  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
18264  }
18265  arg5 = static_cast< PLINT >(val5);
18266  ecode6 = SWIG_AsVal_int(args(5), &val6);
18267  if (!SWIG_IsOK(ecode6)) {
18268  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
18269  }
18270  arg6 = static_cast< PLINT >(val6);
18271  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
18272  _outv = octave_value();
18273  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18274  return _out;
18275  fail:
18276  return octave_value_list();
18277  }
18278  catch(...) {
18279  throw;
18280  }
18281 }
18282 
18283 
18285  octave_value_list _out;
18286  octave_value_list *_outp=&_out;
18287  octave_value _outv;
18288 
18289  try {
18290  if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
18291  SWIG_fail;
18292  }
18293  pleop();
18294  _outv = octave_value();
18295  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18296  return _out;
18297  fail:
18298  return octave_value_list();
18299  }
18300  catch(...) {
18301  throw;
18302  }
18303 }
18304 
18305 
18307  PLINT arg1 ;
18308  PLFLT *arg2 = (PLFLT *) 0 ;
18309  PLFLT *arg3 = (PLFLT *) 0 ;
18310  PLFLT *arg4 = (PLFLT *) 0 ;
18311  Matrix temp1 ;
18312  Matrix temp3 ;
18313  Matrix temp4 ;
18314  octave_value_list _out;
18315  octave_value_list *_outp=&_out;
18316  octave_value _outv;
18317 
18318  try {
18319  if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
18320  SWIG_fail;
18321  }
18322  {
18323  if ( _n_dims( args(0) ) > 1 )
18324  {
18325  error( "argument must be a scalar or vector" ); SWIG_fail;
18326  }
18327  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18328  temp1 = args(0).matrix_value();
18329  arg2 = &temp1( 0, 0 );
18330  }
18331  {
18332  if ( _n_dims( args(1) ) > 1 )
18333  {
18334  error( "argument must be a scalar or vector" ); SWIG_fail;
18335  }
18336  if ( _dim( args(1), 0 ) != Alen )
18337  {
18338  error( "argument vectors must be same length" ); SWIG_fail;
18339  }
18340  temp3 = args(1).matrix_value();
18341  arg3 = &temp3( 0, 0 );
18342  }
18343  {
18344  if ( _n_dims( args(2) ) > 1 )
18345  {
18346  error( "argument must be a scalar or vector" ); SWIG_fail;
18347  }
18348  if ( _dim( args(2), 0 ) != Alen )
18349  {
18350  error( "argument vectors must be same length" ); SWIG_fail;
18351  }
18352  temp4 = args(2).matrix_value();
18353  arg4 = &temp4( 0, 0 );
18354  }
18355  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18356  _outv = octave_value();
18357  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18358  {
18359 
18360  }
18361  {
18362 
18363  }
18364  {
18365 
18366  }
18367  return _out;
18368  fail:
18369  {
18370 
18371  }
18372  {
18373 
18374  }
18375  {
18376 
18377  }
18378  return octave_value_list();
18379  }
18380  catch(...) {
18381  {
18382 
18383  }
18384  {
18385 
18386  }
18387  {
18388 
18389  }
18390  throw;
18391  }
18392 }
18393 
18394 
18396  PLINT arg1 ;
18397  PLFLT *arg2 = (PLFLT *) 0 ;
18398  PLFLT *arg3 = (PLFLT *) 0 ;
18399  PLFLT *arg4 = (PLFLT *) 0 ;
18400  Matrix temp1 ;
18401  Matrix temp3 ;
18402  Matrix temp4 ;
18403  octave_value_list _out;
18404  octave_value_list *_outp=&_out;
18405  octave_value _outv;
18406 
18407  try {
18408  if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
18409  SWIG_fail;
18410  }
18411  {
18412  if ( _n_dims( args(0) ) > 1 )
18413  {
18414  error( "argument must be a scalar or vector" ); SWIG_fail;
18415  }
18416  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18417  temp1 = args(0).matrix_value();
18418  arg2 = &temp1( 0, 0 );
18419  }
18420  {
18421  if ( _n_dims( args(1) ) > 1 )
18422  {
18423  error( "argument must be a scalar or vector" ); SWIG_fail;
18424  }
18425  if ( _dim( args(1), 0 ) != Alen )
18426  {
18427  error( "argument vectors must be same length" ); SWIG_fail;
18428  }
18429  temp3 = args(1).matrix_value();
18430  arg3 = &temp3( 0, 0 );
18431  }
18432  {
18433  if ( _n_dims( args(2) ) > 1 )
18434  {
18435  error( "argument must be a scalar or vector" ); SWIG_fail;
18436  }
18437  if ( _dim( args(2), 0 ) != Alen )
18438  {
18439  error( "argument vectors must be same length" ); SWIG_fail;
18440  }
18441  temp4 = args(2).matrix_value();
18442  arg4 = &temp4( 0, 0 );
18443  }
18444  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18445  _outv = octave_value();
18446  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18447  {
18448 
18449  }
18450  {
18451 
18452  }
18453  {
18454 
18455  }
18456  return _out;
18457  fail:
18458  {
18459 
18460  }
18461  {
18462 
18463  }
18464  {
18465 
18466  }
18467  return octave_value_list();
18468  }
18469  catch(...) {
18470  {
18471 
18472  }
18473  {
18474 
18475  }
18476  {
18477 
18478  }
18479  throw;
18480  }
18481 }
18482 
18483 
18485  octave_value_list _out;
18486  octave_value_list *_outp=&_out;
18487  octave_value _outv;
18488 
18489  try {
18490  if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
18491  SWIG_fail;
18492  }
18493  plfamadv();
18494  _outv = octave_value();
18495  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18496  return _out;
18497  fail:
18498  return octave_value_list();
18499  }
18500  catch(...) {
18501  throw;
18502  }
18503 }
18504 
18505 
18507  PLINT arg1 ;
18508  PLFLT *arg2 = (PLFLT *) 0 ;
18509  PLFLT *arg3 = (PLFLT *) 0 ;
18510  Matrix temp1 ;
18511  Matrix temp3 ;
18512  octave_value_list _out;
18513  octave_value_list *_outp=&_out;
18514  octave_value _outv;
18515 
18516  try {
18517  if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
18518  SWIG_fail;
18519  }
18520  {
18521  if ( _n_dims( args(0) ) > 1 )
18522  {
18523  error( "argument must be a scalar or vector" ); SWIG_fail;
18524  }
18525  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18526  temp1 = args(0).matrix_value();
18527  arg2 = &temp1( 0, 0 );
18528  }
18529  {
18530  if ( _n_dims( args(1) ) > 1 )
18531  {
18532  error( "argument must be a scalar or vector" ); SWIG_fail;
18533  }
18534  if ( _dim( args(1), 0 ) != Alen )
18535  {
18536  error( "argument vectors must be same length" ); SWIG_fail;
18537  }
18538  temp3 = args(1).matrix_value();
18539  arg3 = &temp3( 0, 0 );
18540  }
18541  plfill(arg1,(double const *)arg2,(double const *)arg3);
18542  _outv = octave_value();
18543  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18544  {
18545 
18546  }
18547  {
18548 
18549  }
18550  return _out;
18551  fail:
18552  {
18553 
18554  }
18555  {
18556 
18557  }
18558  return octave_value_list();
18559  }
18560  catch(...) {
18561  {
18562 
18563  }
18564  {
18565 
18566  }
18567  throw;
18568  }
18569 }
18570 
18571 
18573  PLINT arg1 ;
18574  PLFLT *arg2 = (PLFLT *) 0 ;
18575  PLFLT *arg3 = (PLFLT *) 0 ;
18576  PLFLT *arg4 = (PLFLT *) 0 ;
18577  Matrix temp1 ;
18578  Matrix temp3 ;
18579  Matrix temp4 ;
18580  octave_value_list _out;
18581  octave_value_list *_outp=&_out;
18582  octave_value _outv;
18583 
18584  try {
18585  if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
18586  SWIG_fail;
18587  }
18588  {
18589  if ( _n_dims( args(0) ) > 1 )
18590  {
18591  error( "argument must be a scalar or vector" ); SWIG_fail;
18592  }
18593  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18594  temp1 = args(0).matrix_value();
18595  arg2 = &temp1( 0, 0 );
18596  }
18597  {
18598  if ( _n_dims( args(1) ) > 1 )
18599  {
18600  error( "argument must be a scalar or vector" ); SWIG_fail;
18601  }
18602  if ( _dim( args(1), 0 ) != Alen )
18603  {
18604  error( "argument vectors must be same length" ); SWIG_fail;
18605  }
18606  temp3 = args(1).matrix_value();
18607  arg3 = &temp3( 0, 0 );
18608  }
18609  {
18610  if ( _n_dims( args(2) ) > 1 )
18611  {
18612  error( "argument must be a scalar or vector" ); SWIG_fail;
18613  }
18614  if ( _dim( args(2), 0 ) != Alen )
18615  {
18616  error( "argument vectors must be same length" ); SWIG_fail;
18617  }
18618  temp4 = args(2).matrix_value();
18619  arg4 = &temp4( 0, 0 );
18620  }
18621  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
18622  _outv = octave_value();
18623  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18624  {
18625 
18626  }
18627  {
18628 
18629  }
18630  {
18631 
18632  }
18633  return _out;
18634  fail:
18635  {
18636 
18637  }
18638  {
18639 
18640  }
18641  {
18642 
18643  }
18644  return octave_value_list();
18645  }
18646  catch(...) {
18647  {
18648 
18649  }
18650  {
18651 
18652  }
18653  {
18654 
18655  }
18656  throw;
18657  }
18658 }
18659 
18660 
18662  PLINT arg1 ;
18663  PLFLT *arg2 = (PLFLT *) 0 ;
18664  PLFLT *arg3 = (PLFLT *) 0 ;
18665  PLFLT arg4 ;
18666  Matrix temp1 ;
18667  Matrix temp3 ;
18668  double val4 ;
18669  int ecode4 = 0 ;
18670  octave_value_list _out;
18671  octave_value_list *_outp=&_out;
18672  octave_value _outv;
18673 
18674  try {
18675  if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
18676  SWIG_fail;
18677  }
18678  {
18679  if ( _n_dims( args(0) ) > 1 )
18680  {
18681  error( "argument must be a scalar or vector" ); SWIG_fail;
18682  }
18683  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18684  temp1 = args(0).matrix_value();
18685  arg2 = &temp1( 0, 0 );
18686  }
18687  {
18688  if ( _n_dims( args(1) ) > 1 )
18689  {
18690  error( "argument must be a scalar or vector" ); SWIG_fail;
18691  }
18692  if ( _dim( args(1), 0 ) != Alen )
18693  {
18694  error( "argument vectors must be same length" ); SWIG_fail;
18695  }
18696  temp3 = args(1).matrix_value();
18697  arg3 = &temp3( 0, 0 );
18698  }
18699  ecode4 = SWIG_AsVal_double(args(2), &val4);
18700  if (!SWIG_IsOK(ecode4)) {
18701  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
18702  }
18703  arg4 = static_cast< PLFLT >(val4);
18704  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
18705  _outv = octave_value();
18706  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18707  {
18708 
18709  }
18710  {
18711 
18712  }
18713  return _out;
18714  fail:
18715  {
18716 
18717  }
18718  {
18719 
18720  }
18721  return octave_value_list();
18722  }
18723  catch(...) {
18724  {
18725 
18726  }
18727  {
18728 
18729  }
18730  throw;
18731  }
18732 }
18733 
18734 
18736  octave_value_list _out;
18737  octave_value_list *_outp=&_out;
18738  octave_value _outv;
18739 
18740  try {
18741  if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
18742  SWIG_fail;
18743  }
18744  plflush();
18745  _outv = octave_value();
18746  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18747  return _out;
18748  fail:
18749  return octave_value_list();
18750  }
18751  catch(...) {
18752  throw;
18753  }
18754 }
18755 
18756 
18758  PLINT arg1 ;
18759  int val1 ;
18760  int ecode1 = 0 ;
18761  octave_value_list _out;
18762  octave_value_list *_outp=&_out;
18763  octave_value _outv;
18764 
18765  try {
18766  if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
18767  SWIG_fail;
18768  }
18769  ecode1 = SWIG_AsVal_int(args(0), &val1);
18770  if (!SWIG_IsOK(ecode1)) {
18771  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
18772  }
18773  arg1 = static_cast< PLINT >(val1);
18774  plfont(arg1);
18775  _outv = octave_value();
18776  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18777  return _out;
18778  fail:
18779  return octave_value_list();
18780  }
18781  catch(...) {
18782  throw;
18783  }
18784 }
18785 
18786 
18788  PLINT arg1 ;
18789  int val1 ;
18790  int ecode1 = 0 ;
18791  octave_value_list _out;
18792  octave_value_list *_outp=&_out;
18793  octave_value _outv;
18794 
18795  try {
18796  if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
18797  SWIG_fail;
18798  }
18799  ecode1 = SWIG_AsVal_int(args(0), &val1);
18800  if (!SWIG_IsOK(ecode1)) {
18801  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
18802  }
18803  arg1 = static_cast< PLINT >(val1);
18804  plfontld(arg1);
18805  _outv = octave_value();
18806  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18807  return _out;
18808  fail:
18809  return octave_value_list();
18810  }
18811  catch(...) {
18812  throw;
18813  }
18814 }
18815 
18816 
18818  PLFLT *arg1 = (PLFLT *) 0 ;
18819  PLFLT *arg2 = (PLFLT *) 0 ;
18820  PLFLT temp1 ;
18821  int res1 = SWIG_TMPOBJ ;
18822  PLFLT temp2 ;
18823  int res2 = SWIG_TMPOBJ ;
18824  octave_value_list _out;
18825  octave_value_list *_outp=&_out;
18826  octave_value _outv;
18827 
18828  try {
18829  arg1 = &temp1;
18830  arg2 = &temp2;
18831  if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
18832  SWIG_fail;
18833  }
18834  plgchr(arg1,arg2);
18835  _outv = octave_value();
18836  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18837  if (SWIG_IsTmpObj(res1)) {
18838  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18839  } else {
18840  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18841  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18842  }
18843  if (SWIG_IsTmpObj(res2)) {
18844  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18845  } else {
18846  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18847  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18848  }
18849  return _out;
18850  fail:
18851  return octave_value_list();
18852  }
18853  catch(...) {
18854  throw;
18855  }
18856 }
18857 
18858 
18860  PLINT arg1 ;
18861  PLINT *arg2 = (PLINT *) 0 ;
18862  PLINT *arg3 = (PLINT *) 0 ;
18863  PLINT *arg4 = (PLINT *) 0 ;
18864  int val1 ;
18865  int ecode1 = 0 ;
18866  PLINT temp2 ;
18867  int res2 = SWIG_TMPOBJ ;
18868  PLINT temp3 ;
18869  int res3 = SWIG_TMPOBJ ;
18870  PLINT temp4 ;
18871  int res4 = SWIG_TMPOBJ ;
18872  octave_value_list _out;
18873  octave_value_list *_outp=&_out;
18874  octave_value _outv;
18875 
18876  try {
18877  arg2 = &temp2;
18878  arg3 = &temp3;
18879  arg4 = &temp4;
18880  if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
18881  SWIG_fail;
18882  }
18883  ecode1 = SWIG_AsVal_int(args(0), &val1);
18884  if (!SWIG_IsOK(ecode1)) {
18885  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
18886  }
18887  arg1 = static_cast< PLINT >(val1);
18888  plgcol0(arg1,arg2,arg3,arg4);
18889  _outv = octave_value();
18890  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18891  if (SWIG_IsTmpObj(res2)) {
18892  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18893  } else {
18894  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18895  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18896  }
18897  if (SWIG_IsTmpObj(res3)) {
18898  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18899  } else {
18900  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18901  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18902  }
18903  if (SWIG_IsTmpObj(res4)) {
18904  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18905  } else {
18906  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18907  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18908  }
18909  return _out;
18910  fail:
18911  return octave_value_list();
18912  }
18913  catch(...) {
18914  throw;
18915  }
18916 }
18917 
18918 
18920  PLINT arg1 ;
18921  PLINT *arg2 = (PLINT *) 0 ;
18922  PLINT *arg3 = (PLINT *) 0 ;
18923  PLINT *arg4 = (PLINT *) 0 ;
18924  PLFLT *arg5 = (PLFLT *) 0 ;
18925  int val1 ;
18926  int ecode1 = 0 ;
18927  PLINT temp2 ;
18928  int res2 = SWIG_TMPOBJ ;
18929  PLINT temp3 ;
18930  int res3 = SWIG_TMPOBJ ;
18931  PLINT temp4 ;
18932  int res4 = SWIG_TMPOBJ ;
18933  PLFLT temp5 ;
18934  int res5 = SWIG_TMPOBJ ;
18935  octave_value_list _out;
18936  octave_value_list *_outp=&_out;
18937  octave_value _outv;
18938 
18939  try {
18940  arg2 = &temp2;
18941  arg3 = &temp3;
18942  arg4 = &temp4;
18943  arg5 = &temp5;
18944  if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
18945  SWIG_fail;
18946  }
18947  ecode1 = SWIG_AsVal_int(args(0), &val1);
18948  if (!SWIG_IsOK(ecode1)) {
18949  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
18950  }
18951  arg1 = static_cast< PLINT >(val1);
18952  plgcol0a(arg1,arg2,arg3,arg4,arg5);
18953  _outv = octave_value();
18954  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18955  if (SWIG_IsTmpObj(res2)) {
18956  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18957  } else {
18958  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18959  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18960  }
18961  if (SWIG_IsTmpObj(res3)) {
18962  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18963  } else {
18964  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18965  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18966  }
18967  if (SWIG_IsTmpObj(res4)) {
18968  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18969  } else {
18970  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18971  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18972  }
18973  if (SWIG_IsTmpObj(res5)) {
18974  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
18975  } else {
18976  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18977  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
18978  }
18979  return _out;
18980  fail:
18981  return octave_value_list();
18982  }
18983  catch(...) {
18984  throw;
18985  }
18986 }
18987 
18988 
18990  PLINT *arg1 = (PLINT *) 0 ;
18991  PLINT *arg2 = (PLINT *) 0 ;
18992  PLINT *arg3 = (PLINT *) 0 ;
18993  PLINT temp1 ;
18994  int res1 = SWIG_TMPOBJ ;
18995  PLINT temp2 ;
18996  int res2 = SWIG_TMPOBJ ;
18997  PLINT temp3 ;
18998  int res3 = SWIG_TMPOBJ ;
18999  octave_value_list _out;
19000  octave_value_list *_outp=&_out;
19001  octave_value _outv;
19002 
19003  try {
19004  arg1 = &temp1;
19005  arg2 = &temp2;
19006  arg3 = &temp3;
19007  if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
19008  SWIG_fail;
19009  }
19010  plgcolbg(arg1,arg2,arg3);
19011  _outv = octave_value();
19012  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19013  if (SWIG_IsTmpObj(res1)) {
19014  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19015  } else {
19016  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19017  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19018  }
19019  if (SWIG_IsTmpObj(res2)) {
19020  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19021  } else {
19022  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19023  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19024  }
19025  if (SWIG_IsTmpObj(res3)) {
19026  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19027  } else {
19028  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19029  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19030  }
19031  return _out;
19032  fail:
19033  return octave_value_list();
19034  }
19035  catch(...) {
19036  throw;
19037  }
19038 }
19039 
19040 
19042  PLINT *arg1 = (PLINT *) 0 ;
19043  PLINT *arg2 = (PLINT *) 0 ;
19044  PLINT *arg3 = (PLINT *) 0 ;
19045  PLFLT *arg4 = (PLFLT *) 0 ;
19046  PLINT temp1 ;
19047  int res1 = SWIG_TMPOBJ ;
19048  PLINT temp2 ;
19049  int res2 = SWIG_TMPOBJ ;
19050  PLINT temp3 ;
19051  int res3 = SWIG_TMPOBJ ;
19052  PLFLT temp4 ;
19053  int res4 = SWIG_TMPOBJ ;
19054  octave_value_list _out;
19055  octave_value_list *_outp=&_out;
19056  octave_value _outv;
19057 
19058  try {
19059  arg1 = &temp1;
19060  arg2 = &temp2;
19061  arg3 = &temp3;
19062  arg4 = &temp4;
19063  if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
19064  SWIG_fail;
19065  }
19066  plgcolbga(arg1,arg2,arg3,arg4);
19067  _outv = octave_value();
19068  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19069  if (SWIG_IsTmpObj(res1)) {
19070  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19071  } else {
19072  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19073  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19074  }
19075  if (SWIG_IsTmpObj(res2)) {
19076  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19077  } else {
19078  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19079  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19080  }
19081  if (SWIG_IsTmpObj(res3)) {
19082  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19083  } else {
19084  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19085  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19086  }
19087  if (SWIG_IsTmpObj(res4)) {
19088  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19089  } else {
19090  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19091  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19092  }
19093  return _out;
19094  fail:
19095  return octave_value_list();
19096  }
19097  catch(...) {
19098  throw;
19099  }
19100 }
19101 
19102 
19104  PLINT *arg1 = (PLINT *) 0 ;
19105  PLINT temp1 ;
19106  int res1 = SWIG_TMPOBJ ;
19107  octave_value_list _out;
19108  octave_value_list *_outp=&_out;
19109  octave_value _outv;
19110 
19111  try {
19112  arg1 = &temp1;
19113  if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
19114  SWIG_fail;
19115  }
19116  plgcompression(arg1);
19117  _outv = octave_value();
19118  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19119  if (SWIG_IsTmpObj(res1)) {
19120  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19121  } else {
19122  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19123  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19124  }
19125  return _out;
19126  fail:
19127  return octave_value_list();
19128  }
19129  catch(...) {
19130  throw;
19131  }
19132 }
19133 
19134 
19136  char *arg1 = (char *) 0 ;
19137  char local_string1[80] ;
19138  size_t local_string_length1 ;
19139  charMatrix local_charMatrix1 ;
19140  octave_value_list retval1 ;
19141  octave_value_list _out;
19142  octave_value_list *_outp=&_out;
19143  octave_value _outv;
19144 
19145  try {
19146  {
19147  arg1 = local_string1;
19148  }
19149  if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
19150  SWIG_fail;
19151  }
19152  plgdev(arg1);
19153  _outv = octave_value();
19154  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19155  {
19156  local_string_length1 = strlen( local_string1 );
19157  local_charMatrix1 = charMatrix( 1, local_string_length1 );
19158  local_charMatrix1.insert( local_string1, 0, 0 );
19159  retval1( 0 ) = octave_value( local_charMatrix1 );
19160  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19161  }
19162  return _out;
19163  fail:
19164  return octave_value_list();
19165  }
19166  catch(...) {
19167  throw;
19168  }
19169 }
19170 
19171 
19173  PLFLT *arg1 = (PLFLT *) 0 ;
19174  PLFLT *arg2 = (PLFLT *) 0 ;
19175  PLFLT *arg3 = (PLFLT *) 0 ;
19176  PLFLT *arg4 = (PLFLT *) 0 ;
19177  PLFLT temp1 ;
19178  int res1 = SWIG_TMPOBJ ;
19179  PLFLT temp2 ;
19180  int res2 = SWIG_TMPOBJ ;
19181  PLFLT temp3 ;
19182  int res3 = SWIG_TMPOBJ ;
19183  PLFLT temp4 ;
19184  int res4 = SWIG_TMPOBJ ;
19185  octave_value_list _out;
19186  octave_value_list *_outp=&_out;
19187  octave_value _outv;
19188 
19189  try {
19190  arg1 = &temp1;
19191  arg2 = &temp2;
19192  arg3 = &temp3;
19193  arg4 = &temp4;
19194  if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
19195  SWIG_fail;
19196  }
19197  plgdidev(arg1,arg2,arg3,arg4);
19198  _outv = octave_value();
19199  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19200  if (SWIG_IsTmpObj(res1)) {
19201  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19202  } else {
19203  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19204  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19205  }
19206  if (SWIG_IsTmpObj(res2)) {
19207  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19208  } else {
19209  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19210  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19211  }
19212  if (SWIG_IsTmpObj(res3)) {
19213  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19214  } else {
19215  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19216  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19217  }
19218  if (SWIG_IsTmpObj(res4)) {
19219  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19220  } else {
19221  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19222  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19223  }
19224  return _out;
19225  fail:
19226  return octave_value_list();
19227  }
19228  catch(...) {
19229  throw;
19230  }
19231 }
19232 
19233 
19235  PLFLT *arg1 = (PLFLT *) 0 ;
19236  PLFLT temp1 ;
19237  int res1 = SWIG_TMPOBJ ;
19238  octave_value_list _out;
19239  octave_value_list *_outp=&_out;
19240  octave_value _outv;
19241 
19242  try {
19243  arg1 = &temp1;
19244  if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
19245  SWIG_fail;
19246  }
19247  plgdiori(arg1);
19248  _outv = octave_value();
19249  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19250  if (SWIG_IsTmpObj(res1)) {
19251  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19252  } else {
19253  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19254  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19255  }
19256  return _out;
19257  fail:
19258  return octave_value_list();
19259  }
19260  catch(...) {
19261  throw;
19262  }
19263 }
19264 
19265 
19267  PLFLT *arg1 = (PLFLT *) 0 ;
19268  PLFLT *arg2 = (PLFLT *) 0 ;
19269  PLFLT *arg3 = (PLFLT *) 0 ;
19270  PLFLT *arg4 = (PLFLT *) 0 ;
19271  PLFLT temp1 ;
19272  int res1 = SWIG_TMPOBJ ;
19273  PLFLT temp2 ;
19274  int res2 = SWIG_TMPOBJ ;
19275  PLFLT temp3 ;
19276  int res3 = SWIG_TMPOBJ ;
19277  PLFLT temp4 ;
19278  int res4 = SWIG_TMPOBJ ;
19279  octave_value_list _out;
19280  octave_value_list *_outp=&_out;
19281  octave_value _outv;
19282 
19283  try {
19284  arg1 = &temp1;
19285  arg2 = &temp2;
19286  arg3 = &temp3;
19287  arg4 = &temp4;
19288  if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
19289  SWIG_fail;
19290  }
19291  plgdiplt(arg1,arg2,arg3,arg4);
19292  _outv = octave_value();
19293  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19294  if (SWIG_IsTmpObj(res1)) {
19295  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19296  } else {
19297  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19298  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19299  }
19300  if (SWIG_IsTmpObj(res2)) {
19301  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19302  } else {
19303  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19304  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19305  }
19306  if (SWIG_IsTmpObj(res3)) {
19307  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19308  } else {
19309  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19310  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19311  }
19312  if (SWIG_IsTmpObj(res4)) {
19313  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19314  } else {
19315  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19316  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19317  }
19318  return _out;
19319  fail:
19320  return octave_value_list();
19321  }
19322  catch(...) {
19323  throw;
19324  }
19325 }
19326 
19327 
19329  PLINT *arg1 = (PLINT *) 0 ;
19330  PLINT *arg2 = (PLINT *) 0 ;
19331  PLINT *arg3 = (PLINT *) 0 ;
19332  PLINT temp1 ;
19333  int res1 = SWIG_TMPOBJ ;
19334  PLINT temp2 ;
19335  int res2 = SWIG_TMPOBJ ;
19336  PLINT temp3 ;
19337  int res3 = SWIG_TMPOBJ ;
19338  octave_value_list _out;
19339  octave_value_list *_outp=&_out;
19340  octave_value _outv;
19341 
19342  try {
19343  arg1 = &temp1;
19344  arg2 = &temp2;
19345  arg3 = &temp3;
19346  if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
19347  SWIG_fail;
19348  }
19349  plgfam(arg1,arg2,arg3);
19350  _outv = octave_value();
19351  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19352  if (SWIG_IsTmpObj(res1)) {
19353  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19354  } else {
19355  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19356  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19357  }
19358  if (SWIG_IsTmpObj(res2)) {
19359  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19360  } else {
19361  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19362  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19363  }
19364  if (SWIG_IsTmpObj(res3)) {
19365  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19366  } else {
19367  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19368  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19369  }
19370  return _out;
19371  fail:
19372  return octave_value_list();
19373  }
19374  catch(...) {
19375  throw;
19376  }
19377 }
19378 
19379 
19381  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
19382  PLUNICODE temp1 ;
19383  int res1 = SWIG_TMPOBJ ;
19384  octave_value_list _out;
19385  octave_value_list *_outp=&_out;
19386  octave_value _outv;
19387 
19388  try {
19389  arg1 = &temp1;
19390  if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
19391  SWIG_fail;
19392  }
19393  plgfci(arg1);
19394  _outv = octave_value();
19395  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19396  if (SWIG_IsTmpObj(res1)) {
19397  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
19398  } else {
19399  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19400  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
19401  }
19402  return _out;
19403  fail:
19404  return octave_value_list();
19405  }
19406  catch(...) {
19407  throw;
19408  }
19409 }
19410 
19411 
19413  char *arg1 = (char *) 0 ;
19414  char local_string1[80] ;
19415  size_t local_string_length1 ;
19416  charMatrix local_charMatrix1 ;
19417  octave_value_list retval1 ;
19418  octave_value_list _out;
19419  octave_value_list *_outp=&_out;
19420  octave_value _outv;
19421 
19422  try {
19423  {
19424  arg1 = local_string1;
19425  }
19426  if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
19427  SWIG_fail;
19428  }
19429  plgfnam(arg1);
19430  _outv = octave_value();
19431  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19432  {
19433  local_string_length1 = strlen( local_string1 );
19434  local_charMatrix1 = charMatrix( 1, local_string_length1 );
19435  local_charMatrix1.insert( local_string1, 0, 0 );
19436  retval1( 0 ) = octave_value( local_charMatrix1 );
19437  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19438  }
19439  return _out;
19440  fail:
19441  return octave_value_list();
19442  }
19443  catch(...) {
19444  throw;
19445  }
19446 }
19447 
19448 
19450  PLINT *arg1 = (PLINT *) 0 ;
19451  PLINT *arg2 = (PLINT *) 0 ;
19452  PLINT *arg3 = (PLINT *) 0 ;
19453  PLINT temp1 ;
19454  int res1 = SWIG_TMPOBJ ;
19455  PLINT temp2 ;
19456  int res2 = SWIG_TMPOBJ ;
19457  PLINT temp3 ;
19458  int res3 = SWIG_TMPOBJ ;
19459  octave_value_list _out;
19460  octave_value_list *_outp=&_out;
19461  octave_value _outv;
19462 
19463  try {
19464  arg1 = &temp1;
19465  arg2 = &temp2;
19466  arg3 = &temp3;
19467  if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
19468  SWIG_fail;
19469  }
19470  plgfont(arg1,arg2,arg3);
19471  _outv = octave_value();
19472  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19473  if (SWIG_IsTmpObj(res1)) {
19474  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19475  } else {
19476  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19477  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19478  }
19479  if (SWIG_IsTmpObj(res2)) {
19480  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19481  } else {
19482  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19483  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19484  }
19485  if (SWIG_IsTmpObj(res3)) {
19486  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19487  } else {
19488  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19489  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19490  }
19491  return _out;
19492  fail:
19493  return octave_value_list();
19494  }
19495  catch(...) {
19496  throw;
19497  }
19498 }
19499 
19500 
19502  PLINT *arg1 = (PLINT *) 0 ;
19503  PLINT temp1 ;
19504  int res1 = SWIG_TMPOBJ ;
19505  octave_value_list _out;
19506  octave_value_list *_outp=&_out;
19507  octave_value _outv;
19508 
19509  try {
19510  arg1 = &temp1;
19511  if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
19512  SWIG_fail;
19513  }
19514  plglevel(arg1);
19515  _outv = octave_value();
19516  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19517  if (SWIG_IsTmpObj(res1)) {
19518  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19519  } else {
19520  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19521  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19522  }
19523  return _out;
19524  fail:
19525  return octave_value_list();
19526  }
19527  catch(...) {
19528  throw;
19529  }
19530 }
19531 
19532 
19534  PLFLT *arg1 = (PLFLT *) 0 ;
19535  PLFLT *arg2 = (PLFLT *) 0 ;
19536  PLINT *arg3 = (PLINT *) 0 ;
19537  PLINT *arg4 = (PLINT *) 0 ;
19538  PLINT *arg5 = (PLINT *) 0 ;
19539  PLINT *arg6 = (PLINT *) 0 ;
19540  PLFLT temp1 ;
19541  int res1 = SWIG_TMPOBJ ;
19542  PLFLT temp2 ;
19543  int res2 = SWIG_TMPOBJ ;
19544  PLINT temp3 ;
19545  int res3 = SWIG_TMPOBJ ;
19546  PLINT temp4 ;
19547  int res4 = SWIG_TMPOBJ ;
19548  PLINT temp5 ;
19549  int res5 = SWIG_TMPOBJ ;
19550  PLINT temp6 ;
19551  int res6 = SWIG_TMPOBJ ;
19552  octave_value_list _out;
19553  octave_value_list *_outp=&_out;
19554  octave_value _outv;
19555 
19556  try {
19557  arg1 = &temp1;
19558  arg2 = &temp2;
19559  arg3 = &temp3;
19560  arg4 = &temp4;
19561  arg5 = &temp5;
19562  arg6 = &temp6;
19563  if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
19564  SWIG_fail;
19565  }
19566  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
19567  _outv = octave_value();
19568  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19569  if (SWIG_IsTmpObj(res1)) {
19570  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19571  } else {
19572  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19573  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19574  }
19575  if (SWIG_IsTmpObj(res2)) {
19576  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19577  } else {
19578  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19579  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19580  }
19581  if (SWIG_IsTmpObj(res3)) {
19582  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
19583  } else {
19584  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19585  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
19586  }
19587  if (SWIG_IsTmpObj(res4)) {
19588  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
19589  } else {
19590  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19591  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
19592  }
19593  if (SWIG_IsTmpObj(res5)) {
19594  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
19595  } else {
19596  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19597  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
19598  }
19599  if (SWIG_IsTmpObj(res6)) {
19600  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
19601  } else {
19602  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19603  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
19604  }
19605  return _out;
19606  fail:
19607  return octave_value_list();
19608  }
19609  catch(...) {
19610  throw;
19611  }
19612 }
19613 
19614 
19616  octave_value_list _out;
19617  octave_value_list *_outp=&_out;
19618  octave_value _outv;
19619 
19620  try {
19621  if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
19622  SWIG_fail;
19623  }
19624  plgra();
19625  _outv = octave_value();
19626  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19627  return _out;
19628  fail:
19629  return octave_value_list();
19630  }
19631  catch(...) {
19632  throw;
19633  }
19634 }
19635 
19636 
19638  PLFLT *arg1 = (PLFLT *) 0 ;
19639  PLFLT *arg2 = (PLFLT *) 0 ;
19640  PLFLT *arg3 = (PLFLT *) 0 ;
19641  PLFLT *arg4 = (PLFLT *) 0 ;
19642  PLFLT temp1 ;
19643  int res1 = SWIG_TMPOBJ ;
19644  PLFLT temp2 ;
19645  int res2 = SWIG_TMPOBJ ;
19646  PLFLT temp3 ;
19647  int res3 = SWIG_TMPOBJ ;
19648  PLFLT temp4 ;
19649  int res4 = SWIG_TMPOBJ ;
19650  octave_value_list _out;
19651  octave_value_list *_outp=&_out;
19652  octave_value _outv;
19653 
19654  try {
19655  arg1 = &temp1;
19656  arg2 = &temp2;
19657  arg3 = &temp3;
19658  arg4 = &temp4;
19659  if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
19660  SWIG_fail;
19661  }
19662  plgspa(arg1,arg2,arg3,arg4);
19663  _outv = octave_value();
19664  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19665  if (SWIG_IsTmpObj(res1)) {
19666  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19667  } else {
19668  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19669  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19670  }
19671  if (SWIG_IsTmpObj(res2)) {
19672  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19673  } else {
19674  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19675  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19676  }
19677  if (SWIG_IsTmpObj(res3)) {
19678  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19679  } else {
19680  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19681  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19682  }
19683  if (SWIG_IsTmpObj(res4)) {
19684  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19685  } else {
19686  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19687  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19688  }
19689  return _out;
19690  fail:
19691  return octave_value_list();
19692  }
19693  catch(...) {
19694  throw;
19695  }
19696 }
19697 
19698 
19700  PLINT *arg1 = (PLINT *) 0 ;
19701  PLINT temp1 ;
19702  int res1 = SWIG_TMPOBJ ;
19703  octave_value_list _out;
19704  octave_value_list *_outp=&_out;
19705  octave_value _outv;
19706 
19707  try {
19708  arg1 = &temp1;
19709  if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
19710  SWIG_fail;
19711  }
19712  plgstrm(arg1);
19713  _outv = octave_value();
19714  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19715  if (SWIG_IsTmpObj(res1)) {
19716  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19717  } else {
19718  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19719  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19720  }
19721  return _out;
19722  fail:
19723  return octave_value_list();
19724  }
19725  catch(...) {
19726  throw;
19727  }
19728 }
19729 
19730 
19732  char *arg1 = (char *) 0 ;
19733  char local_string1[80] ;
19734  size_t local_string_length1 ;
19735  charMatrix local_charMatrix1 ;
19736  octave_value_list retval1 ;
19737  octave_value_list _out;
19738  octave_value_list *_outp=&_out;
19739  octave_value _outv;
19740 
19741  try {
19742  {
19743  arg1 = local_string1;
19744  }
19745  if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
19746  SWIG_fail;
19747  }
19748  plgver(arg1);
19749  _outv = octave_value();
19750  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19751  {
19752  local_string_length1 = strlen( local_string1 );
19753  local_charMatrix1 = charMatrix( 1, local_string_length1 );
19754  local_charMatrix1.insert( local_string1, 0, 0 );
19755  retval1( 0 ) = octave_value( local_charMatrix1 );
19756  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
19757  }
19758  return _out;
19759  fail:
19760  return octave_value_list();
19761  }
19762  catch(...) {
19763  throw;
19764  }
19765 }
19766 
19767 
19769  PLFLT *arg1 = (PLFLT *) 0 ;
19770  PLFLT *arg2 = (PLFLT *) 0 ;
19771  PLFLT *arg3 = (PLFLT *) 0 ;
19772  PLFLT *arg4 = (PLFLT *) 0 ;
19773  PLFLT temp1 ;
19774  int res1 = SWIG_TMPOBJ ;
19775  PLFLT temp2 ;
19776  int res2 = SWIG_TMPOBJ ;
19777  PLFLT temp3 ;
19778  int res3 = SWIG_TMPOBJ ;
19779  PLFLT temp4 ;
19780  int res4 = SWIG_TMPOBJ ;
19781  octave_value_list _out;
19782  octave_value_list *_outp=&_out;
19783  octave_value _outv;
19784 
19785  try {
19786  arg1 = &temp1;
19787  arg2 = &temp2;
19788  arg3 = &temp3;
19789  arg4 = &temp4;
19790  if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
19791  SWIG_fail;
19792  }
19793  plgvpd(arg1,arg2,arg3,arg4);
19794  _outv = octave_value();
19795  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19796  if (SWIG_IsTmpObj(res1)) {
19797  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19798  } else {
19799  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19800  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19801  }
19802  if (SWIG_IsTmpObj(res2)) {
19803  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19804  } else {
19805  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19806  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19807  }
19808  if (SWIG_IsTmpObj(res3)) {
19809  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19810  } else {
19811  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19812  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19813  }
19814  if (SWIG_IsTmpObj(res4)) {
19815  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19816  } else {
19817  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19818  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19819  }
19820  return _out;
19821  fail:
19822  return octave_value_list();
19823  }
19824  catch(...) {
19825  throw;
19826  }
19827 }
19828 
19829 
19831  PLFLT *arg1 = (PLFLT *) 0 ;
19832  PLFLT *arg2 = (PLFLT *) 0 ;
19833  PLFLT *arg3 = (PLFLT *) 0 ;
19834  PLFLT *arg4 = (PLFLT *) 0 ;
19835  PLFLT temp1 ;
19836  int res1 = SWIG_TMPOBJ ;
19837  PLFLT temp2 ;
19838  int res2 = SWIG_TMPOBJ ;
19839  PLFLT temp3 ;
19840  int res3 = SWIG_TMPOBJ ;
19841  PLFLT temp4 ;
19842  int res4 = SWIG_TMPOBJ ;
19843  octave_value_list _out;
19844  octave_value_list *_outp=&_out;
19845  octave_value _outv;
19846 
19847  try {
19848  arg1 = &temp1;
19849  arg2 = &temp2;
19850  arg3 = &temp3;
19851  arg4 = &temp4;
19852  if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
19853  SWIG_fail;
19854  }
19855  plgvpw(arg1,arg2,arg3,arg4);
19856  _outv = octave_value();
19857  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19858  if (SWIG_IsTmpObj(res1)) {
19859  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19860  } else {
19861  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19862  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19863  }
19864  if (SWIG_IsTmpObj(res2)) {
19865  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19866  } else {
19867  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19868  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19869  }
19870  if (SWIG_IsTmpObj(res3)) {
19871  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
19872  } else {
19873  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19874  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
19875  }
19876  if (SWIG_IsTmpObj(res4)) {
19877  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19878  } else {
19879  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19880  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19881  }
19882  return _out;
19883  fail:
19884  return octave_value_list();
19885  }
19886  catch(...) {
19887  throw;
19888  }
19889 }
19890 
19891 
19893  PLINT *arg1 = (PLINT *) 0 ;
19894  PLINT *arg2 = (PLINT *) 0 ;
19895  PLINT temp1 ;
19896  int res1 = SWIG_TMPOBJ ;
19897  PLINT temp2 ;
19898  int res2 = SWIG_TMPOBJ ;
19899  octave_value_list _out;
19900  octave_value_list *_outp=&_out;
19901  octave_value _outv;
19902 
19903  try {
19904  arg1 = &temp1;
19905  arg2 = &temp2;
19906  if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
19907  SWIG_fail;
19908  }
19909  plgxax(arg1,arg2);
19910  _outv = octave_value();
19911  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19912  if (SWIG_IsTmpObj(res1)) {
19913  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19914  } else {
19915  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19916  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19917  }
19918  if (SWIG_IsTmpObj(res2)) {
19919  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19920  } else {
19921  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19922  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19923  }
19924  return _out;
19925  fail:
19926  return octave_value_list();
19927  }
19928  catch(...) {
19929  throw;
19930  }
19931 }
19932 
19933 
19935  PLINT *arg1 = (PLINT *) 0 ;
19936  PLINT *arg2 = (PLINT *) 0 ;
19937  PLINT temp1 ;
19938  int res1 = SWIG_TMPOBJ ;
19939  PLINT temp2 ;
19940  int res2 = SWIG_TMPOBJ ;
19941  octave_value_list _out;
19942  octave_value_list *_outp=&_out;
19943  octave_value _outv;
19944 
19945  try {
19946  arg1 = &temp1;
19947  arg2 = &temp2;
19948  if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
19949  SWIG_fail;
19950  }
19951  plgyax(arg1,arg2);
19952  _outv = octave_value();
19953  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19954  if (SWIG_IsTmpObj(res1)) {
19955  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19956  } else {
19957  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19958  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
19959  }
19960  if (SWIG_IsTmpObj(res2)) {
19961  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
19962  } else {
19963  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19964  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
19965  }
19966  return _out;
19967  fail:
19968  return octave_value_list();
19969  }
19970  catch(...) {
19971  throw;
19972  }
19973 }
19974 
19975 
19977  PLINT *arg1 = (PLINT *) 0 ;
19978  PLINT *arg2 = (PLINT *) 0 ;
19979  PLINT temp1 ;
19980  int res1 = SWIG_TMPOBJ ;
19981  PLINT temp2 ;
19982  int res2 = SWIG_TMPOBJ ;
19983  octave_value_list _out;
19984  octave_value_list *_outp=&_out;
19985  octave_value _outv;
19986 
19987  try {
19988  arg1 = &temp1;
19989  arg2 = &temp2;
19990  if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
19991  SWIG_fail;
19992  }
19993  plgzax(arg1,arg2);
19994  _outv = octave_value();
19995  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19996  if (SWIG_IsTmpObj(res1)) {
19997  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
19998  } else {
19999  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20000  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20001  }
20002  if (SWIG_IsTmpObj(res2)) {
20003  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20004  } else {
20005  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20006  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20007  }
20008  return _out;
20009  fail:
20010  return octave_value_list();
20011  }
20012  catch(...) {
20013  throw;
20014  }
20015 }
20016 
20017 
20019  PLINT arg1 ;
20020  PLFLT *arg2 = (PLFLT *) 0 ;
20021  PLFLT arg3 ;
20022  PLFLT arg4 ;
20023  PLINT arg5 ;
20024  PLINT arg6 ;
20025  Matrix temp1 ;
20026  double val3 ;
20027  int ecode3 = 0 ;
20028  double val4 ;
20029  int ecode4 = 0 ;
20030  int val5 ;
20031  int ecode5 = 0 ;
20032  int val6 ;
20033  int ecode6 = 0 ;
20034  octave_value_list _out;
20035  octave_value_list *_outp=&_out;
20036  octave_value _outv;
20037 
20038  try {
20039  if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
20040  SWIG_fail;
20041  }
20042  {
20043  if ( _n_dims( args(0) ) > 1 )
20044  {
20045  error( "argument must be a scalar or vector" ); SWIG_fail;
20046  }
20047  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20048  temp1 = args(0).matrix_value();
20049  arg2 = &temp1( 0, 0 );
20050  }
20051  ecode3 = SWIG_AsVal_double(args(1), &val3);
20052  if (!SWIG_IsOK(ecode3)) {
20053  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
20054  }
20055  arg3 = static_cast< PLFLT >(val3);
20056  ecode4 = SWIG_AsVal_double(args(2), &val4);
20057  if (!SWIG_IsOK(ecode4)) {
20058  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
20059  }
20060  arg4 = static_cast< PLFLT >(val4);
20061  ecode5 = SWIG_AsVal_int(args(3), &val5);
20062  if (!SWIG_IsOK(ecode5)) {
20063  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
20064  }
20065  arg5 = static_cast< PLINT >(val5);
20066  ecode6 = SWIG_AsVal_int(args(4), &val6);
20067  if (!SWIG_IsOK(ecode6)) {
20068  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
20069  }
20070  arg6 = static_cast< PLINT >(val6);
20071  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
20072  _outv = octave_value();
20073  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20074  {
20075 
20076  }
20077  return _out;
20078  fail:
20079  {
20080 
20081  }
20082  return octave_value_list();
20083  }
20084  catch(...) {
20085  {
20086 
20087  }
20088  throw;
20089  }
20090 }
20091 
20092 
20094  PLFLT arg1 ;
20095  PLFLT arg2 ;
20096  PLFLT arg3 ;
20097  PLFLT *arg4 = (PLFLT *) 0 ;
20098  PLFLT *arg5 = (PLFLT *) 0 ;
20099  PLFLT *arg6 = (PLFLT *) 0 ;
20100  double val1 ;
20101  int ecode1 = 0 ;
20102  double val2 ;
20103  int ecode2 = 0 ;
20104  double val3 ;
20105  int ecode3 = 0 ;
20106  PLFLT temp4 ;
20107  int res4 = SWIG_TMPOBJ ;
20108  PLFLT temp5 ;
20109  int res5 = SWIG_TMPOBJ ;
20110  PLFLT temp6 ;
20111  int res6 = SWIG_TMPOBJ ;
20112  octave_value_list _out;
20113  octave_value_list *_outp=&_out;
20114  octave_value _outv;
20115 
20116  try {
20117  arg4 = &temp4;
20118  arg5 = &temp5;
20119  arg6 = &temp6;
20120  if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
20121  SWIG_fail;
20122  }
20123  ecode1 = SWIG_AsVal_double(args(0), &val1);
20124  if (!SWIG_IsOK(ecode1)) {
20125  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
20126  }
20127  arg1 = static_cast< PLFLT >(val1);
20128  ecode2 = SWIG_AsVal_double(args(1), &val2);
20129  if (!SWIG_IsOK(ecode2)) {
20130  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
20131  }
20132  arg2 = static_cast< PLFLT >(val2);
20133  ecode3 = SWIG_AsVal_double(args(2), &val3);
20134  if (!SWIG_IsOK(ecode3)) {
20135  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
20136  }
20137  arg3 = static_cast< PLFLT >(val3);
20138  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
20139  _outv = octave_value();
20140  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20141  if (SWIG_IsTmpObj(res4)) {
20142  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
20143  } else {
20144  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20145  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
20146  }
20147  if (SWIG_IsTmpObj(res5)) {
20148  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
20149  } else {
20150  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20151  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
20152  }
20153  if (SWIG_IsTmpObj(res6)) {
20154  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
20155  } else {
20156  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20157  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
20158  }
20159  return _out;
20160  fail:
20161  return octave_value_list();
20162  }
20163  catch(...) {
20164  throw;
20165  }
20166 }
20167 
20168 
20170  octave_value_list _out;
20171  octave_value_list *_outp=&_out;
20172  octave_value _outv;
20173 
20174  try {
20175  if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
20176  SWIG_fail;
20177  }
20178  plinit();
20179  _outv = octave_value();
20180  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20181  return _out;
20182  fail:
20183  return octave_value_list();
20184  }
20185  catch(...) {
20186  throw;
20187  }
20188 }
20189 
20190 
20192  PLFLT arg1 ;
20193  PLFLT arg2 ;
20194  PLFLT arg3 ;
20195  PLFLT arg4 ;
20196  double val1 ;
20197  int ecode1 = 0 ;
20198  double val2 ;
20199  int ecode2 = 0 ;
20200  double val3 ;
20201  int ecode3 = 0 ;
20202  double val4 ;
20203  int ecode4 = 0 ;
20204  octave_value_list _out;
20205  octave_value_list *_outp=&_out;
20206  octave_value _outv;
20207 
20208  try {
20209  if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
20210  SWIG_fail;
20211  }
20212  ecode1 = SWIG_AsVal_double(args(0), &val1);
20213  if (!SWIG_IsOK(ecode1)) {
20214  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
20215  }
20216  arg1 = static_cast< PLFLT >(val1);
20217  ecode2 = SWIG_AsVal_double(args(1), &val2);
20218  if (!SWIG_IsOK(ecode2)) {
20219  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
20220  }
20221  arg2 = static_cast< PLFLT >(val2);
20222  ecode3 = SWIG_AsVal_double(args(2), &val3);
20223  if (!SWIG_IsOK(ecode3)) {
20224  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
20225  }
20226  arg3 = static_cast< PLFLT >(val3);
20227  ecode4 = SWIG_AsVal_double(args(3), &val4);
20228  if (!SWIG_IsOK(ecode4)) {
20229  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
20230  }
20231  arg4 = static_cast< PLFLT >(val4);
20232  pljoin(arg1,arg2,arg3,arg4);
20233  _outv = octave_value();
20234  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20235  return _out;
20236  fail:
20237  return octave_value_list();
20238  }
20239  catch(...) {
20240  throw;
20241  }
20242 }
20243 
20244 
20246  char *arg1 = (char *) 0 ;
20247  char *arg2 = (char *) 0 ;
20248  char *arg3 = (char *) 0 ;
20249  int res1 ;
20250  char *buf1 = 0 ;
20251  int alloc1 = 0 ;
20252  int res2 ;
20253  char *buf2 = 0 ;
20254  int alloc2 = 0 ;
20255  int res3 ;
20256  char *buf3 = 0 ;
20257  int alloc3 = 0 ;
20258  octave_value_list _out;
20259  octave_value_list *_outp=&_out;
20260  octave_value _outv;
20261 
20262  try {
20263  if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
20264  SWIG_fail;
20265  }
20266  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20267  if (!SWIG_IsOK(res1)) {
20268  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
20269  }
20270  arg1 = reinterpret_cast< char * >(buf1);
20271  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20272  if (!SWIG_IsOK(res2)) {
20273  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
20274  }
20275  arg2 = reinterpret_cast< char * >(buf2);
20276  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
20277  if (!SWIG_IsOK(res3)) {
20278  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
20279  }
20280  arg3 = reinterpret_cast< char * >(buf3);
20281  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
20282  _outv = octave_value();
20283  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20284  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20285  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20286  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20287  return _out;
20288  fail:
20289  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20290  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20291  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20292  return octave_value_list();
20293  }
20294  catch(...) {
20295  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20296  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20297  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
20298  throw;
20299  }
20300 }
20301 
20302 
20304  PLFLT *arg1 = (PLFLT *) 0 ;
20305  PLFLT *arg2 = (PLFLT *) 0 ;
20306  PLINT arg3 ;
20307  PLINT arg4 ;
20308  PLFLT arg5 ;
20309  PLFLT arg6 ;
20310  PLFLT arg7 ;
20311  PLINT arg8 ;
20312  PLINT arg9 ;
20313  PLINT arg10 ;
20314  PLINT arg11 ;
20315  PLINT arg12 ;
20316  PLINT arg13 ;
20317  PLINT *arg14 = (PLINT *) 0 ;
20318  PLFLT arg15 ;
20319  PLFLT arg16 ;
20320  PLFLT arg17 ;
20321  PLFLT arg18 ;
20322  PLINT *arg19 = (PLINT *) 0 ;
20323  char **arg20 = (char **) 0 ;
20324  PLINT *arg21 = (PLINT *) 0 ;
20325  PLINT *arg22 = (PLINT *) 0 ;
20326  PLFLT *arg23 = (PLFLT *) 0 ;
20327  PLFLT *arg24 = (PLFLT *) 0 ;
20328  PLINT *arg25 = (PLINT *) 0 ;
20329  PLINT *arg26 = (PLINT *) 0 ;
20330  PLFLT *arg27 = (PLFLT *) 0 ;
20331  PLINT *arg28 = (PLINT *) 0 ;
20332  PLFLT *arg29 = (PLFLT *) 0 ;
20333  PLINT *arg30 = (PLINT *) 0 ;
20334  char **arg31 = (char **) 0 ;
20335  PLFLT temp1 ;
20336  int res1 = SWIG_TMPOBJ ;
20337  PLFLT temp2 ;
20338  int res2 = SWIG_TMPOBJ ;
20339  int val3 ;
20340  int ecode3 = 0 ;
20341  int val4 ;
20342  int ecode4 = 0 ;
20343  double val5 ;
20344  int ecode5 = 0 ;
20345  double val6 ;
20346  int ecode6 = 0 ;
20347  double val7 ;
20348  int ecode7 = 0 ;
20349  int val8 ;
20350  int ecode8 = 0 ;
20351  int val9 ;
20352  int ecode9 = 0 ;
20353  int val10 ;
20354  int ecode10 = 0 ;
20355  int val11 ;
20356  int ecode11 = 0 ;
20357  int val12 ;
20358  int ecode12 = 0 ;
20359  Matrix temp13 ;
20360  double val15 ;
20361  int ecode15 = 0 ;
20362  double val16 ;
20363  int ecode16 = 0 ;
20364  double val17 ;
20365  int ecode17 = 0 ;
20366  double val18 ;
20367  int ecode18 = 0 ;
20368  Matrix temp19 ;
20369  Matrix temp21 ;
20370  Matrix temp22 ;
20371  Matrix temp23 ;
20372  Matrix temp24 ;
20373  Matrix temp25 ;
20374  Matrix temp26 ;
20375  Matrix temp27 ;
20376  Matrix temp28 ;
20377  Matrix temp29 ;
20378  Matrix temp30 ;
20379  octave_value_list _out;
20380  octave_value_list *_outp=&_out;
20381  octave_value _outv;
20382 
20383  try {
20384  arg1 = &temp1;
20385  arg2 = &temp2;
20386  if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
20387  SWIG_fail;
20388  }
20389  ecode3 = SWIG_AsVal_int(args(0), &val3);
20390  if (!SWIG_IsOK(ecode3)) {
20391  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
20392  }
20393  arg3 = static_cast< PLINT >(val3);
20394  ecode4 = SWIG_AsVal_int(args(1), &val4);
20395  if (!SWIG_IsOK(ecode4)) {
20396  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
20397  }
20398  arg4 = static_cast< PLINT >(val4);
20399  ecode5 = SWIG_AsVal_double(args(2), &val5);
20400  if (!SWIG_IsOK(ecode5)) {
20401  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
20402  }
20403  arg5 = static_cast< PLFLT >(val5);
20404  ecode6 = SWIG_AsVal_double(args(3), &val6);
20405  if (!SWIG_IsOK(ecode6)) {
20406  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
20407  }
20408  arg6 = static_cast< PLFLT >(val6);
20409  ecode7 = SWIG_AsVal_double(args(4), &val7);
20410  if (!SWIG_IsOK(ecode7)) {
20411  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
20412  }
20413  arg7 = static_cast< PLFLT >(val7);
20414  ecode8 = SWIG_AsVal_int(args(5), &val8);
20415  if (!SWIG_IsOK(ecode8)) {
20416  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
20417  }
20418  arg8 = static_cast< PLINT >(val8);
20419  ecode9 = SWIG_AsVal_int(args(6), &val9);
20420  if (!SWIG_IsOK(ecode9)) {
20421  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
20422  }
20423  arg9 = static_cast< PLINT >(val9);
20424  ecode10 = SWIG_AsVal_int(args(7), &val10);
20425  if (!SWIG_IsOK(ecode10)) {
20426  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
20427  }
20428  arg10 = static_cast< PLINT >(val10);
20429  ecode11 = SWIG_AsVal_int(args(8), &val11);
20430  if (!SWIG_IsOK(ecode11)) {
20431  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
20432  }
20433  arg11 = static_cast< PLINT >(val11);
20434  ecode12 = SWIG_AsVal_int(args(9), &val12);
20435  if (!SWIG_IsOK(ecode12)) {
20436  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
20437  }
20438  arg12 = static_cast< PLINT >(val12);
20439  {
20440  if ( _n_dims( args(10) ) > 1 )
20441  {
20442  error( "argument must be a scalar or vector" ); SWIG_fail;
20443  }
20444  arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
20445  arg14 = new PLINT[Alen];
20446  temp13 = args(10).matrix_value();
20447  _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
20448  }
20449  ecode15 = SWIG_AsVal_double(args(11), &val15);
20450  if (!SWIG_IsOK(ecode15)) {
20451  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
20452  }
20453  arg15 = static_cast< PLFLT >(val15);
20454  ecode16 = SWIG_AsVal_double(args(12), &val16);
20455  if (!SWIG_IsOK(ecode16)) {
20456  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
20457  }
20458  arg16 = static_cast< PLFLT >(val16);
20459  ecode17 = SWIG_AsVal_double(args(13), &val17);
20460  if (!SWIG_IsOK(ecode17)) {
20461  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
20462  }
20463  arg17 = static_cast< PLFLT >(val17);
20464  ecode18 = SWIG_AsVal_double(args(14), &val18);
20465  if (!SWIG_IsOK(ecode18)) {
20466  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
20467  }
20468  arg18 = static_cast< PLFLT >(val18);
20469  {
20470  if ( _n_dims( args(15) ) > 1 )
20471  {
20472  error( "argument must be a scalar or vector" ); SWIG_fail;
20473  }
20474  if ( _dim( args(15), 0 ) != Alen )
20475  {
20476  error( "argument vectors must be same length" ); SWIG_fail;
20477  }
20478  temp19 = args(15).matrix_value();
20479  arg19 = new PLINT[Alen];
20480  _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
20481  }
20482  {
20483  charMatrix temp_matrix;
20484  Cell temp_cell;
20485  char *tmp_cstring;
20486  std::string str;
20487  size_t max_length = 0, non_blank_length;
20488  int i, ifcell;
20489  if ( _n_dims( args(16) ) > 2 )
20490  {
20491  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20492  }
20493 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20494  if ( !args(16).isempty() )
20495 #else
20496  if ( !args(16).is_empty() )
20497 #endif
20498  {
20499  if ( _dim( args(16), 0 ) != Alen )
20500  {
20501  error( "first dimension must be same length as previous vector" ); SWIG_fail;
20502  }
20503  arg20 = new char*[Alen];
20504 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20505  ifcell = args(16).iscell();
20506 #else
20507  ifcell = args(16).is_cell();
20508 #endif
20509  if ( ifcell )
20510  {
20511  temp_cell = args(16).cell_value();
20512  }
20513  else
20514  {
20515  temp_matrix = args(16).char_matrix_value();
20516  // Allow one extra space for null termination.
20517  max_length = _dim( args(16), 1 ) + 1;
20518  }
20519 
20520  for ( i = 0; i < Alen; i++ )
20521  {
20522  // Must copy string to "permanent" location because the string
20523  // location corresponding to tmp_cstring gets
20524  // overwritten for each iteration of loop.
20525  if ( ifcell )
20526  {
20527  if ( temp_cell.elem( i ).is_string() )
20528  {
20529  str = temp_cell.elem( i ).string_value();
20530  // leave room for null termination.
20531  max_length = str.size() + 1;
20532  tmp_cstring = (char *) str.c_str();
20533  }
20534  else
20535  {
20536  // Use null string if user attempts to pass a cell array
20537  // with a non-string element (likely an empty element
20538  // since that should be allowed by the PLplot interface
20539  // if that element is going to be unused).
20540  // leave room for null termination.
20541  max_length = 1;
20542  tmp_cstring = (char *) "";
20543  }
20544  }
20545  else
20546  {
20547  str = temp_matrix.row_as_string( i );
20548  tmp_cstring = (char *) str.c_str();
20549  }
20550  arg20[i] = new char[max_length];
20551  strncpy( arg20[i], tmp_cstring, max_length - 1 );
20552  arg20[i][max_length - 1] = '\0';
20553  // All the trailing blank crapola should not be needed for
20554  // string cell arrays.
20555  if ( !ifcell )
20556  {
20557  // remove trailing-blank padding that is used by the
20558  // charMatrix class to insure all strings in a given
20559  // charMatrix instance have the same length.
20560  // This transformation also removes legitimate trailing
20561  // blanks but there is nothing we can do about that
20562  // for the charMatrix class.
20563 
20564  // Look for trailing nulls first (just in case, although that
20565  // shouldn't happen if charMatrix implemented as documented)
20566  // before looking for trailing blanks.
20567  non_blank_length = max_length - 2;
20568  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
20569  {
20570  non_blank_length--;
20571  }
20572  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
20573  {
20574  non_blank_length--;
20575  }
20576  arg20[i][non_blank_length + 1] = '\0';
20577  }
20578  }
20579  }
20580  else
20581  {
20582  arg20 = NULL;
20583  }
20584  }
20585  {
20586  if ( _n_dims( args(17) ) > 1 )
20587  {
20588  error( "argument must be a scalar or vector" ); SWIG_fail;
20589  }
20590 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20591  if ( !args(17).isempty() )
20592 #else
20593  if ( !args(17).is_empty() )
20594 #endif
20595  {
20596  if ( _dim( args(17), 0 ) != Alen )
20597  {
20598  error( "argument vectors must be same length" ); SWIG_fail;
20599  }
20600  temp21 = args(17).matrix_value();
20601  arg21 = new PLINT[Alen];
20602  _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
20603  }
20604  else
20605  {
20606  arg21 = NULL;
20607  }
20608  }
20609  {
20610  if ( _n_dims( args(18) ) > 1 )
20611  {
20612  error( "argument must be a scalar or vector" ); SWIG_fail;
20613  }
20614 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20615  if ( !args(18).isempty() )
20616 #else
20617  if ( !args(18).is_empty() )
20618 #endif
20619  {
20620  if ( _dim( args(18), 0 ) != Alen )
20621  {
20622  error( "argument vectors must be same length" ); SWIG_fail;
20623  }
20624  temp22 = args(18).matrix_value();
20625  arg22 = new PLINT[Alen];
20626  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
20627  }
20628  else
20629  {
20630  arg22 = NULL;
20631  }
20632  }
20633  {
20634  if ( _n_dims( args(19) ) > 1 )
20635  {
20636  error( "argument must be a scalar or vector" ); SWIG_fail;
20637  }
20638 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20639  if ( !args(19).isempty() )
20640 #else
20641  if ( !args(19).is_empty() )
20642 #endif
20643  {
20644  if ( _dim( args(19), 0 ) != Alen )
20645  {
20646  error( "argument vectors must be same length" ); SWIG_fail;
20647  }
20648  temp23 = args(19).matrix_value();
20649  arg23 = &temp23( 0, 0 );
20650  }
20651  else
20652  {
20653  arg23 = NULL;
20654  }
20655  }
20656  {
20657  if ( _n_dims( args(20) ) > 1 )
20658  {
20659  error( "argument must be a scalar or vector" ); SWIG_fail;
20660  }
20661 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20662  if ( !args(20).isempty() )
20663 #else
20664  if ( !args(20).is_empty() )
20665 #endif
20666  {
20667  if ( _dim( args(20), 0 ) != Alen )
20668  {
20669  error( "argument vectors must be same length" ); SWIG_fail;
20670  }
20671  temp24 = args(20).matrix_value();
20672  arg24 = &temp24( 0, 0 );
20673  }
20674  else
20675  {
20676  arg24 = NULL;
20677  }
20678  }
20679  {
20680  if ( _n_dims( args(21) ) > 1 )
20681  {
20682  error( "argument must be a scalar or vector" ); SWIG_fail;
20683  }
20684 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20685  if ( !args(21).isempty() )
20686 #else
20687  if ( !args(21).is_empty() )
20688 #endif
20689  {
20690  if ( _dim( args(21), 0 ) != Alen )
20691  {
20692  error( "argument vectors must be same length" ); SWIG_fail;
20693  }
20694  temp25 = args(21).matrix_value();
20695  arg25 = new PLINT[Alen];
20696  _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
20697  }
20698  else
20699  {
20700  arg25 = NULL;
20701  }
20702  }
20703  {
20704  if ( _n_dims( args(22) ) > 1 )
20705  {
20706  error( "argument must be a scalar or vector" ); SWIG_fail;
20707  }
20708 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20709  if ( !args(22).isempty() )
20710 #else
20711  if ( !args(22).is_empty() )
20712 #endif
20713  {
20714  if ( _dim( args(22), 0 ) != Alen )
20715  {
20716  error( "argument vectors must be same length" ); SWIG_fail;
20717  }
20718  temp26 = args(22).matrix_value();
20719  arg26 = new PLINT[Alen];
20720  _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
20721  }
20722  else
20723  {
20724  arg26 = NULL;
20725  }
20726  }
20727  {
20728  if ( _n_dims( args(23) ) > 1 )
20729  {
20730  error( "argument must be a scalar or vector" ); SWIG_fail;
20731  }
20732 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20733  if ( !args(23).isempty() )
20734 #else
20735  if ( !args(23).is_empty() )
20736 #endif
20737  {
20738  if ( _dim( args(23), 0 ) != Alen )
20739  {
20740  error( "argument vectors must be same length" ); SWIG_fail;
20741  }
20742  temp27 = args(23).matrix_value();
20743  arg27 = &temp27( 0, 0 );
20744  }
20745  else
20746  {
20747  arg27 = NULL;
20748  }
20749  }
20750  {
20751  if ( _n_dims( args(24) ) > 1 )
20752  {
20753  error( "argument must be a scalar or vector" ); SWIG_fail;
20754  }
20755 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20756  if ( !args(24).isempty() )
20757 #else
20758  if ( !args(24).is_empty() )
20759 #endif
20760  {
20761  if ( _dim( args(24), 0 ) != Alen )
20762  {
20763  error( "argument vectors must be same length" ); SWIG_fail;
20764  }
20765  temp28 = args(24).matrix_value();
20766  arg28 = new PLINT[Alen];
20767  _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
20768  }
20769  else
20770  {
20771  arg28 = NULL;
20772  }
20773  }
20774  {
20775  if ( _n_dims( args(25) ) > 1 )
20776  {
20777  error( "argument must be a scalar or vector" ); SWIG_fail;
20778  }
20779 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20780  if ( !args(25).isempty() )
20781 #else
20782  if ( !args(25).is_empty() )
20783 #endif
20784  {
20785  if ( _dim( args(25), 0 ) != Alen )
20786  {
20787  error( "argument vectors must be same length" ); SWIG_fail;
20788  }
20789  temp29 = args(25).matrix_value();
20790  arg29 = &temp29( 0, 0 );
20791  }
20792  else
20793  {
20794  arg29 = NULL;
20795  }
20796  }
20797  {
20798  if ( _n_dims( args(26) ) > 1 )
20799  {
20800  error( "argument must be a scalar or vector" ); SWIG_fail;
20801  }
20802 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20803  if ( !args(26).isempty() )
20804 #else
20805  if ( !args(26).is_empty() )
20806 #endif
20807  {
20808  if ( _dim( args(26), 0 ) != Alen )
20809  {
20810  error( "argument vectors must be same length" ); SWIG_fail;
20811  }
20812  temp30 = args(26).matrix_value();
20813  arg30 = new PLINT[Alen];
20814  _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
20815  }
20816  else
20817  {
20818  arg30 = NULL;
20819  }
20820  }
20821  {
20822  charMatrix temp_matrix;
20823  Cell temp_cell;
20824  char *tmp_cstring;
20825  std::string str;
20826  size_t max_length = 0, non_blank_length;
20827  int i, ifcell;
20828  if ( _n_dims( args(27) ) > 2 )
20829  {
20830  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
20831  }
20832 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20833  if ( !args(27).isempty() )
20834 #else
20835  if ( !args(27).is_empty() )
20836 #endif
20837  {
20838  if ( _dim( args(27), 0 ) != Alen )
20839  {
20840  error( "first dimension must be same length as previous vector" ); SWIG_fail;
20841  }
20842  arg31 = new char*[Alen];
20843 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
20844  ifcell = args(27).iscell();
20845 #else
20846  ifcell = args(27).is_cell();
20847 #endif
20848  if ( ifcell )
20849  {
20850  temp_cell = args(27).cell_value();
20851  }
20852  else
20853  {
20854  temp_matrix = args(27).char_matrix_value();
20855  // Allow one extra space for null termination.
20856  max_length = _dim( args(27), 1 ) + 1;
20857  }
20858 
20859  for ( i = 0; i < Alen; i++ )
20860  {
20861  // Must copy string to "permanent" location because the string
20862  // location corresponding to tmp_cstring gets
20863  // overwritten for each iteration of loop.
20864  if ( ifcell )
20865  {
20866  if ( temp_cell.elem( i ).is_string() )
20867  {
20868  str = temp_cell.elem( i ).string_value();
20869  // leave room for null termination.
20870  max_length = str.size() + 1;
20871  tmp_cstring = (char *) str.c_str();
20872  }
20873  else
20874  {
20875  // Use null string if user attempts to pass a cell array
20876  // with a non-string element (likely an empty element
20877  // since that should be allowed by the PLplot interface
20878  // if that element is going to be unused).
20879  // leave room for null termination.
20880  max_length = 1;
20881  tmp_cstring = (char *) "";
20882  }
20883  }
20884  else
20885  {
20886  str = temp_matrix.row_as_string( i );
20887  tmp_cstring = (char *) str.c_str();
20888  }
20889  arg31[i] = new char[max_length];
20890  strncpy( arg31[i], tmp_cstring, max_length - 1 );
20891  arg31[i][max_length - 1] = '\0';
20892  // All the trailing blank crapola should not be needed for
20893  // string cell arrays.
20894  if ( !ifcell )
20895  {
20896  // remove trailing-blank padding that is used by the
20897  // charMatrix class to insure all strings in a given
20898  // charMatrix instance have the same length.
20899  // This transformation also removes legitimate trailing
20900  // blanks but there is nothing we can do about that
20901  // for the charMatrix class.
20902 
20903  // Look for trailing nulls first (just in case, although that
20904  // shouldn't happen if charMatrix implemented as documented)
20905  // before looking for trailing blanks.
20906  non_blank_length = max_length - 2;
20907  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
20908  {
20909  non_blank_length--;
20910  }
20911  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
20912  {
20913  non_blank_length--;
20914  }
20915  arg31[i][non_blank_length + 1] = '\0';
20916  }
20917  }
20918  }
20919  else
20920  {
20921  arg31 = NULL;
20922  }
20923  }
20924  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);
20925  _outv = octave_value();
20926  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20927  if (SWIG_IsTmpObj(res1)) {
20928  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
20929  } else {
20930  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20931  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
20932  }
20933  if (SWIG_IsTmpObj(res2)) {
20934  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
20935  } else {
20936  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20937  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
20938  }
20939  {
20940  delete [] arg14;
20941  }
20942  {
20943  delete [] arg19;
20944  }
20945  {
20946  int i;
20947  if ( arg20 != NULL )
20948  {
20949  for ( i = 0; i < Alen; i++ )
20950  {
20951  delete[] arg20[i];
20952  }
20953  delete[] arg20;
20954  }
20955  }
20956  {
20957  if ( arg21 != NULL )
20958  delete [] arg21;
20959  }
20960  {
20961  if ( arg22 != NULL )
20962  delete [] arg22;
20963  }
20964  {
20965 
20966  }
20967  {
20968 
20969  }
20970  {
20971  if ( arg25 != NULL )
20972  delete [] arg25;
20973  }
20974  {
20975  if ( arg26 != NULL )
20976  delete [] arg26;
20977  }
20978  {
20979 
20980  }
20981  {
20982  if ( arg28 != NULL )
20983  delete [] arg28;
20984  }
20985  {
20986 
20987  }
20988  {
20989  if ( arg30 != NULL )
20990  delete [] arg30;
20991  }
20992  {
20993  int i;
20994  if ( arg31 != NULL )
20995  {
20996  for ( i = 0; i < Alen; i++ )
20997  {
20998  delete[] arg31[i];
20999  }
21000  delete[] arg31;
21001  }
21002  }
21003  return _out;
21004  fail:
21005  {
21006  delete [] arg14;
21007  }
21008  {
21009  delete [] arg19;
21010  }
21011  {
21012  int i;
21013  if ( arg20 != NULL )
21014  {
21015  for ( i = 0; i < Alen; i++ )
21016  {
21017  delete[] arg20[i];
21018  }
21019  delete[] arg20;
21020  }
21021  }
21022  {
21023  if ( arg21 != NULL )
21024  delete [] arg21;
21025  }
21026  {
21027  if ( arg22 != NULL )
21028  delete [] arg22;
21029  }
21030  {
21031 
21032  }
21033  {
21034 
21035  }
21036  {
21037  if ( arg25 != NULL )
21038  delete [] arg25;
21039  }
21040  {
21041  if ( arg26 != NULL )
21042  delete [] arg26;
21043  }
21044  {
21045 
21046  }
21047  {
21048  if ( arg28 != NULL )
21049  delete [] arg28;
21050  }
21051  {
21052 
21053  }
21054  {
21055  if ( arg30 != NULL )
21056  delete [] arg30;
21057  }
21058  {
21059  int i;
21060  if ( arg31 != NULL )
21061  {
21062  for ( i = 0; i < Alen; i++ )
21063  {
21064  delete[] arg31[i];
21065  }
21066  delete[] arg31;
21067  }
21068  }
21069  return octave_value_list();
21070  }
21071  catch(...) {
21072  {
21073  delete [] arg14;
21074  }
21075  {
21076  delete [] arg19;
21077  }
21078  {
21079  int i;
21080  if ( arg20 != NULL )
21081  {
21082  for ( i = 0; i < Alen; i++ )
21083  {
21084  delete[] arg20[i];
21085  }
21086  delete[] arg20;
21087  }
21088  }
21089  {
21090  if ( arg21 != NULL )
21091  delete [] arg21;
21092  }
21093  {
21094  if ( arg22 != NULL )
21095  delete [] arg22;
21096  }
21097  {
21098 
21099  }
21100  {
21101 
21102  }
21103  {
21104  if ( arg25 != NULL )
21105  delete [] arg25;
21106  }
21107  {
21108  if ( arg26 != NULL )
21109  delete [] arg26;
21110  }
21111  {
21112 
21113  }
21114  {
21115  if ( arg28 != NULL )
21116  delete [] arg28;
21117  }
21118  {
21119 
21120  }
21121  {
21122  if ( arg30 != NULL )
21123  delete [] arg30;
21124  }
21125  {
21126  int i;
21127  if ( arg31 != NULL )
21128  {
21129  for ( i = 0; i < Alen; i++ )
21130  {
21131  delete[] arg31[i];
21132  }
21133  delete[] arg31;
21134  }
21135  }
21136  throw;
21137  }
21138 }
21139 
21140 
21142  PLFLT arg1 ;
21143  PLFLT arg2 ;
21144  PLFLT arg3 ;
21145  double val1 ;
21146  int ecode1 = 0 ;
21147  double val2 ;
21148  int ecode2 = 0 ;
21149  double val3 ;
21150  int ecode3 = 0 ;
21151  octave_value_list _out;
21152  octave_value_list *_outp=&_out;
21153  octave_value _outv;
21154 
21155  try {
21156  if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
21157  SWIG_fail;
21158  }
21159  ecode1 = SWIG_AsVal_double(args(0), &val1);
21160  if (!SWIG_IsOK(ecode1)) {
21161  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
21162  }
21163  arg1 = static_cast< PLFLT >(val1);
21164  ecode2 = SWIG_AsVal_double(args(1), &val2);
21165  if (!SWIG_IsOK(ecode2)) {
21166  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
21167  }
21168  arg2 = static_cast< PLFLT >(val2);
21169  ecode3 = SWIG_AsVal_double(args(2), &val3);
21170  if (!SWIG_IsOK(ecode3)) {
21171  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
21172  }
21173  arg3 = static_cast< PLFLT >(val3);
21174  pllightsource(arg1,arg2,arg3);
21175  _outv = octave_value();
21176  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21177  return _out;
21178  fail:
21179  return octave_value_list();
21180  }
21181  catch(...) {
21182  throw;
21183  }
21184 }
21185 
21186 
21188  PLINT arg1 ;
21189  PLFLT *arg2 = (PLFLT *) 0 ;
21190  PLFLT *arg3 = (PLFLT *) 0 ;
21191  Matrix temp1 ;
21192  Matrix temp3 ;
21193  octave_value_list _out;
21194  octave_value_list *_outp=&_out;
21195  octave_value _outv;
21196 
21197  try {
21198  if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
21199  SWIG_fail;
21200  }
21201  {
21202  if ( _n_dims( args(0) ) > 1 )
21203  {
21204  error( "argument must be a scalar or vector" ); SWIG_fail;
21205  }
21206  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21207  temp1 = args(0).matrix_value();
21208  arg2 = &temp1( 0, 0 );
21209  }
21210  {
21211  if ( _n_dims( args(1) ) > 1 )
21212  {
21213  error( "argument must be a scalar or vector" ); SWIG_fail;
21214  }
21215  if ( _dim( args(1), 0 ) != Alen )
21216  {
21217  error( "argument vectors must be same length" ); SWIG_fail;
21218  }
21219  temp3 = args(1).matrix_value();
21220  arg3 = &temp3( 0, 0 );
21221  }
21222  plline(arg1,(double const *)arg2,(double const *)arg3);
21223  _outv = octave_value();
21224  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21225  {
21226 
21227  }
21228  {
21229 
21230  }
21231  return _out;
21232  fail:
21233  {
21234 
21235  }
21236  {
21237 
21238  }
21239  return octave_value_list();
21240  }
21241  catch(...) {
21242  {
21243 
21244  }
21245  {
21246 
21247  }
21248  throw;
21249  }
21250 }
21251 
21252 
21254  PLINT arg1 ;
21255  PLFLT *arg2 = (PLFLT *) 0 ;
21256  PLFLT *arg3 = (PLFLT *) 0 ;
21257  PLFLT *arg4 = (PLFLT *) 0 ;
21258  Matrix temp1 ;
21259  Matrix temp3 ;
21260  Matrix temp4 ;
21261  octave_value_list _out;
21262  octave_value_list *_outp=&_out;
21263  octave_value _outv;
21264 
21265  try {
21266  if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
21267  SWIG_fail;
21268  }
21269  {
21270  if ( _n_dims( args(0) ) > 1 )
21271  {
21272  error( "argument must be a scalar or vector" ); SWIG_fail;
21273  }
21274  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21275  temp1 = args(0).matrix_value();
21276  arg2 = &temp1( 0, 0 );
21277  }
21278  {
21279  if ( _n_dims( args(1) ) > 1 )
21280  {
21281  error( "argument must be a scalar or vector" ); SWIG_fail;
21282  }
21283  if ( _dim( args(1), 0 ) != Alen )
21284  {
21285  error( "argument vectors must be same length" ); SWIG_fail;
21286  }
21287  temp3 = args(1).matrix_value();
21288  arg3 = &temp3( 0, 0 );
21289  }
21290  {
21291  if ( _n_dims( args(2) ) > 1 )
21292  {
21293  error( "argument must be a scalar or vector" ); SWIG_fail;
21294  }
21295  if ( _dim( args(2), 0 ) != Alen )
21296  {
21297  error( "argument vectors must be same length" ); SWIG_fail;
21298  }
21299  temp4 = args(2).matrix_value();
21300  arg4 = &temp4( 0, 0 );
21301  }
21302  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
21303  _outv = octave_value();
21304  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21305  {
21306 
21307  }
21308  {
21309 
21310  }
21311  {
21312 
21313  }
21314  return _out;
21315  fail:
21316  {
21317 
21318  }
21319  {
21320 
21321  }
21322  {
21323 
21324  }
21325  return octave_value_list();
21326  }
21327  catch(...) {
21328  {
21329 
21330  }
21331  {
21332 
21333  }
21334  {
21335 
21336  }
21337  throw;
21338  }
21339 }
21340 
21341 
21343  PLINT arg1 ;
21344  int val1 ;
21345  int ecode1 = 0 ;
21346  octave_value_list _out;
21347  octave_value_list *_outp=&_out;
21348  octave_value _outv;
21349 
21350  try {
21351  if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
21352  SWIG_fail;
21353  }
21354  ecode1 = SWIG_AsVal_int(args(0), &val1);
21355  if (!SWIG_IsOK(ecode1)) {
21356  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
21357  }
21358  arg1 = static_cast< PLINT >(val1);
21359  pllsty(arg1);
21360  _outv = octave_value();
21361  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21362  return _out;
21363  fail:
21364  return octave_value_list();
21365  }
21366  catch(...) {
21367  throw;
21368  }
21369 }
21370 
21371 
21373  PLINT *arg1 = (PLINT *) 0 ;
21374  PLINT temp1 ;
21375  int res1 = SWIG_TMPOBJ ;
21376  octave_value_list _out;
21377  octave_value_list *_outp=&_out;
21378  octave_value _outv;
21379 
21380  try {
21381  arg1 = &temp1;
21382  if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
21383  SWIG_fail;
21384  }
21385  plmkstrm(arg1);
21386  _outv = octave_value();
21387  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21388  if (SWIG_IsTmpObj(res1)) {
21389  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
21390  } else {
21391  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21392  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
21393  }
21394  return _out;
21395  fail:
21396  return octave_value_list();
21397  }
21398  catch(...) {
21399  throw;
21400  }
21401 }
21402 
21403 
21405  char *arg1 = (char *) 0 ;
21406  PLFLT arg2 ;
21407  PLFLT arg3 ;
21408  PLFLT arg4 ;
21409  char *arg5 = (char *) 0 ;
21410  int res1 ;
21411  char *buf1 = 0 ;
21412  int alloc1 = 0 ;
21413  double val2 ;
21414  int ecode2 = 0 ;
21415  double val3 ;
21416  int ecode3 = 0 ;
21417  double val4 ;
21418  int ecode4 = 0 ;
21419  int res5 ;
21420  char *buf5 = 0 ;
21421  int alloc5 = 0 ;
21422  octave_value_list _out;
21423  octave_value_list *_outp=&_out;
21424  octave_value _outv;
21425 
21426  try {
21427  if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
21428  SWIG_fail;
21429  }
21430  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21431  if (!SWIG_IsOK(res1)) {
21432  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
21433  }
21434  arg1 = reinterpret_cast< char * >(buf1);
21435  ecode2 = SWIG_AsVal_double(args(1), &val2);
21436  if (!SWIG_IsOK(ecode2)) {
21437  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
21438  }
21439  arg2 = static_cast< PLFLT >(val2);
21440  ecode3 = SWIG_AsVal_double(args(2), &val3);
21441  if (!SWIG_IsOK(ecode3)) {
21442  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
21443  }
21444  arg3 = static_cast< PLFLT >(val3);
21445  ecode4 = SWIG_AsVal_double(args(3), &val4);
21446  if (!SWIG_IsOK(ecode4)) {
21447  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
21448  }
21449  arg4 = static_cast< PLFLT >(val4);
21450  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21451  if (!SWIG_IsOK(res5)) {
21452  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
21453  }
21454  arg5 = reinterpret_cast< char * >(buf5);
21455  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21456  _outv = octave_value();
21457  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21458  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21459  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21460  return _out;
21461  fail:
21462  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21463  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21464  return octave_value_list();
21465  }
21466  catch(...) {
21467  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21468  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21469  throw;
21470  }
21471 }
21472 
21473 
21475  char *arg1 = (char *) 0 ;
21476  PLFLT arg2 ;
21477  PLFLT arg3 ;
21478  PLFLT arg4 ;
21479  char *arg5 = (char *) 0 ;
21480  int res1 ;
21481  char *buf1 = 0 ;
21482  int alloc1 = 0 ;
21483  double val2 ;
21484  int ecode2 = 0 ;
21485  double val3 ;
21486  int ecode3 = 0 ;
21487  double val4 ;
21488  int ecode4 = 0 ;
21489  int res5 ;
21490  char *buf5 = 0 ;
21491  int alloc5 = 0 ;
21492  octave_value_list _out;
21493  octave_value_list *_outp=&_out;
21494  octave_value _outv;
21495 
21496  try {
21497  if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
21498  SWIG_fail;
21499  }
21500  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
21501  if (!SWIG_IsOK(res1)) {
21502  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
21503  }
21504  arg1 = reinterpret_cast< char * >(buf1);
21505  ecode2 = SWIG_AsVal_double(args(1), &val2);
21506  if (!SWIG_IsOK(ecode2)) {
21507  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
21508  }
21509  arg2 = static_cast< PLFLT >(val2);
21510  ecode3 = SWIG_AsVal_double(args(2), &val3);
21511  if (!SWIG_IsOK(ecode3)) {
21512  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
21513  }
21514  arg3 = static_cast< PLFLT >(val3);
21515  ecode4 = SWIG_AsVal_double(args(3), &val4);
21516  if (!SWIG_IsOK(ecode4)) {
21517  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
21518  }
21519  arg4 = static_cast< PLFLT >(val4);
21520  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
21521  if (!SWIG_IsOK(res5)) {
21522  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
21523  }
21524  arg5 = reinterpret_cast< char * >(buf5);
21525  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
21526  _outv = octave_value();
21527  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21528  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21529  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21530  return _out;
21531  fail:
21532  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21533  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21534  return octave_value_list();
21535  }
21536  catch(...) {
21537  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
21538  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
21539  throw;
21540  }
21541 }
21542 
21543 
21545  int *arg1 = (int *) 0 ;
21546  char **arg2 = (char **) 0 ;
21547  PLINT arg3 ;
21548  void *argp1 = 0 ;
21549  int res1 = 0 ;
21550  void *argp2 = 0 ;
21551  int res2 = 0 ;
21552  int val3 ;
21553  int ecode3 = 0 ;
21554  octave_value_list _out;
21555  octave_value_list *_outp=&_out;
21556  octave_value _outv;
21557  PLINT result;
21558 
21559  try {
21560  if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
21561  SWIG_fail;
21562  }
21563  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
21564  if (!SWIG_IsOK(res1)) {
21565  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
21566  }
21567  arg1 = reinterpret_cast< int * >(argp1);
21568  res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
21569  if (!SWIG_IsOK(res2)) {
21570  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
21571  }
21572  arg2 = reinterpret_cast< char ** >(argp2);
21573  ecode3 = SWIG_AsVal_int(args(2), &val3);
21574  if (!SWIG_IsOK(ecode3)) {
21575  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
21576  }
21577  arg3 = static_cast< PLINT >(val3);
21578  result = (PLINT)plparseopts(arg1,arg2,arg3);
21579  _outv = SWIG_From_int(static_cast< int >(result));
21580  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21581  return _out;
21582  fail:
21583  return octave_value_list();
21584  }
21585  catch(...) {
21586  throw;
21587  }
21588 }
21589 
21590 
21592  PLINT arg1 ;
21593  PLINT *arg2 = (PLINT *) 0 ;
21594  PLINT *arg3 = (PLINT *) 0 ;
21595  Matrix temp1 ;
21596  Matrix temp3 ;
21597  octave_value_list _out;
21598  octave_value_list *_outp=&_out;
21599  octave_value _outv;
21600 
21601  try {
21602  if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
21603  SWIG_fail;
21604  }
21605  {
21606  if ( _n_dims( args(0) ) > 1 )
21607  {
21608  error( "argument must be a scalar or vector" ); SWIG_fail;
21609  }
21610  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21611  arg2 = new PLINT[Alen];
21612  temp1 = args(0).matrix_value();
21613  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
21614  }
21615  {
21616  if ( _n_dims( args(1) ) > 1 )
21617  {
21618  error( "argument must be a scalar or vector" ); SWIG_fail;
21619  }
21620  if ( _dim( args(1), 0 ) != Alen )
21621  {
21622  error( "argument vectors must be same length" ); SWIG_fail;
21623  }
21624  temp3 = args(1).matrix_value();
21625  arg3 = new PLINT[Alen];
21626  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21627  }
21628  plpat(arg1,(int const *)arg2,(int const *)arg3);
21629  _outv = octave_value();
21630  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21631  {
21632  delete [] arg2;
21633  }
21634  {
21635  delete [] arg3;
21636  }
21637  return _out;
21638  fail:
21639  {
21640  delete [] arg2;
21641  }
21642  {
21643  delete [] arg3;
21644  }
21645  return octave_value_list();
21646  }
21647  catch(...) {
21648  {
21649  delete [] arg2;
21650  }
21651  {
21652  delete [] arg3;
21653  }
21654  throw;
21655  }
21656 }
21657 
21658 
21660  PLINT arg1 ;
21661  PLFLT arg2 ;
21662  PLFLT arg3 ;
21663  PLFLT arg4 ;
21664  PLFLT arg5 ;
21665  int val1 ;
21666  int ecode1 = 0 ;
21667  double val2 ;
21668  int ecode2 = 0 ;
21669  double val3 ;
21670  int ecode3 = 0 ;
21671  double val4 ;
21672  int ecode4 = 0 ;
21673  double val5 ;
21674  int ecode5 = 0 ;
21675  octave_value_list _out;
21676  octave_value_list *_outp=&_out;
21677  octave_value _outv;
21678 
21679  try {
21680  if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
21681  SWIG_fail;
21682  }
21683  ecode1 = SWIG_AsVal_int(args(0), &val1);
21684  if (!SWIG_IsOK(ecode1)) {
21685  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
21686  }
21687  arg1 = static_cast< PLINT >(val1);
21688  ecode2 = SWIG_AsVal_double(args(1), &val2);
21689  if (!SWIG_IsOK(ecode2)) {
21690  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
21691  }
21692  arg2 = static_cast< PLFLT >(val2);
21693  ecode3 = SWIG_AsVal_double(args(2), &val3);
21694  if (!SWIG_IsOK(ecode3)) {
21695  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
21696  }
21697  arg3 = static_cast< PLFLT >(val3);
21698  ecode4 = SWIG_AsVal_double(args(3), &val4);
21699  if (!SWIG_IsOK(ecode4)) {
21700  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
21701  }
21702  arg4 = static_cast< PLFLT >(val4);
21703  ecode5 = SWIG_AsVal_double(args(4), &val5);
21704  if (!SWIG_IsOK(ecode5)) {
21705  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
21706  }
21707  arg5 = static_cast< PLFLT >(val5);
21708  plpath(arg1,arg2,arg3,arg4,arg5);
21709  _outv = octave_value();
21710  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21711  return _out;
21712  fail:
21713  return octave_value_list();
21714  }
21715  catch(...) {
21716  throw;
21717  }
21718 }
21719 
21720 
21722  PLINT arg1 ;
21723  PLFLT *arg2 = (PLFLT *) 0 ;
21724  PLFLT *arg3 = (PLFLT *) 0 ;
21725  PLINT arg4 ;
21726  Matrix temp1 ;
21727  Matrix temp3 ;
21728  int val4 ;
21729  int ecode4 = 0 ;
21730  octave_value_list _out;
21731  octave_value_list *_outp=&_out;
21732  octave_value _outv;
21733 
21734  try {
21735  if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
21736  SWIG_fail;
21737  }
21738  {
21739  if ( _n_dims( args(0) ) > 1 )
21740  {
21741  error( "argument must be a scalar or vector" ); SWIG_fail;
21742  }
21743  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21744  temp1 = args(0).matrix_value();
21745  arg2 = &temp1( 0, 0 );
21746  }
21747  {
21748  if ( _n_dims( args(1) ) > 1 )
21749  {
21750  error( "argument must be a scalar or vector" ); SWIG_fail;
21751  }
21752  if ( _dim( args(1), 0 ) != Alen )
21753  {
21754  error( "argument vectors must be same length" ); SWIG_fail;
21755  }
21756  temp3 = args(1).matrix_value();
21757  arg3 = &temp3( 0, 0 );
21758  }
21759  ecode4 = SWIG_AsVal_int(args(2), &val4);
21760  if (!SWIG_IsOK(ecode4)) {
21761  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
21762  }
21763  arg4 = static_cast< PLINT >(val4);
21764  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
21765  _outv = octave_value();
21766  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21767  {
21768 
21769  }
21770  {
21771 
21772  }
21773  return _out;
21774  fail:
21775  {
21776 
21777  }
21778  {
21779 
21780  }
21781  return octave_value_list();
21782  }
21783  catch(...) {
21784  {
21785 
21786  }
21787  {
21788 
21789  }
21790  throw;
21791  }
21792 }
21793 
21794 
21796  PLINT arg1 ;
21797  PLFLT *arg2 = (PLFLT *) 0 ;
21798  PLFLT *arg3 = (PLFLT *) 0 ;
21799  PLFLT *arg4 = (PLFLT *) 0 ;
21800  PLINT arg5 ;
21801  Matrix temp1 ;
21802  Matrix temp3 ;
21803  Matrix temp4 ;
21804  int val5 ;
21805  int ecode5 = 0 ;
21806  octave_value_list _out;
21807  octave_value_list *_outp=&_out;
21808  octave_value _outv;
21809 
21810  try {
21811  if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
21812  SWIG_fail;
21813  }
21814  {
21815  if ( _n_dims( args(0) ) > 1 )
21816  {
21817  error( "argument must be a scalar or vector" ); SWIG_fail;
21818  }
21819  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21820  temp1 = args(0).matrix_value();
21821  arg2 = &temp1( 0, 0 );
21822  }
21823  {
21824  if ( _n_dims( args(1) ) > 1 )
21825  {
21826  error( "argument must be a scalar or vector" ); SWIG_fail;
21827  }
21828  if ( _dim( args(1), 0 ) != Alen )
21829  {
21830  error( "argument vectors must be same length" ); SWIG_fail;
21831  }
21832  temp3 = args(1).matrix_value();
21833  arg3 = &temp3( 0, 0 );
21834  }
21835  {
21836  if ( _n_dims( args(2) ) > 1 )
21837  {
21838  error( "argument must be a scalar or vector" ); SWIG_fail;
21839  }
21840  if ( _dim( args(2), 0 ) != Alen )
21841  {
21842  error( "argument vectors must be same length" ); SWIG_fail;
21843  }
21844  temp4 = args(2).matrix_value();
21845  arg4 = &temp4( 0, 0 );
21846  }
21847  ecode5 = SWIG_AsVal_int(args(3), &val5);
21848  if (!SWIG_IsOK(ecode5)) {
21849  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
21850  }
21851  arg5 = static_cast< PLINT >(val5);
21852  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
21853  _outv = octave_value();
21854  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21855  {
21856 
21857  }
21858  {
21859 
21860  }
21861  {
21862 
21863  }
21864  return _out;
21865  fail:
21866  {
21867 
21868  }
21869  {
21870 
21871  }
21872  {
21873 
21874  }
21875  return octave_value_list();
21876  }
21877  catch(...) {
21878  {
21879 
21880  }
21881  {
21882 
21883  }
21884  {
21885 
21886  }
21887  throw;
21888  }
21889 }
21890 
21891 
21893  PLINT arg1 ;
21894  PLFLT *arg2 = (PLFLT *) 0 ;
21895  PLFLT *arg3 = (PLFLT *) 0 ;
21896  PLFLT *arg4 = (PLFLT *) 0 ;
21897  PLBOOL *arg5 = (PLBOOL *) 0 ;
21898  PLBOOL arg6 ;
21899  Matrix temp1 ;
21900  Matrix temp3 ;
21901  Matrix temp4 ;
21902  Matrix temp5 ;
21903  int val6 ;
21904  int ecode6 = 0 ;
21905  octave_value_list _out;
21906  octave_value_list *_outp=&_out;
21907  octave_value _outv;
21908 
21909  try {
21910  if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
21911  SWIG_fail;
21912  }
21913  {
21914  if ( _n_dims( args(0) ) > 1 )
21915  {
21916  error( "argument must be a scalar or vector" ); SWIG_fail;
21917  }
21918  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
21919  temp1 = args(0).matrix_value();
21920  arg2 = &temp1( 0, 0 );
21921  }
21922  {
21923  if ( _n_dims( args(1) ) > 1 )
21924  {
21925  error( "argument must be a scalar or vector" ); SWIG_fail;
21926  }
21927  if ( _dim( args(1), 0 ) != Alen )
21928  {
21929  error( "argument vectors must be same length" ); SWIG_fail;
21930  }
21931  temp3 = args(1).matrix_value();
21932  arg3 = &temp3( 0, 0 );
21933  }
21934  {
21935  if ( _n_dims( args(2) ) > 1 )
21936  {
21937  error( "argument must be a scalar or vector" ); SWIG_fail;
21938  }
21939  if ( _dim( args(2), 0 ) != Alen )
21940  {
21941  error( "argument vectors must be same length" ); SWIG_fail;
21942  }
21943  temp4 = args(2).matrix_value();
21944  arg4 = &temp4( 0, 0 );
21945  }
21946  {
21947  if ( _n_dims( args(3) ) > 1 )
21948  {
21949  error( "argument must be a scalar or vector" ); SWIG_fail;
21950  }
21951  if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
21952  {
21953  error( "argument vector must be same length or one less" ); SWIG_fail;
21954  }
21955  temp5 = args(3).matrix_value();
21956  arg5 = new PLINT[Alen];
21957  _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
21958  }
21959  ecode6 = SWIG_AsVal_int(args(4), &val6);
21960  if (!SWIG_IsOK(ecode6)) {
21961  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
21962  }
21963  arg6 = static_cast< PLBOOL >(val6);
21964  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
21965  _outv = octave_value();
21966  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21967  {
21968 
21969  }
21970  {
21971 
21972  }
21973  {
21974 
21975  }
21976  {
21977  delete [] arg5;
21978  }
21979  return _out;
21980  fail:
21981  {
21982 
21983  }
21984  {
21985 
21986  }
21987  {
21988 
21989  }
21990  {
21991  delete [] arg5;
21992  }
21993  return octave_value_list();
21994  }
21995  catch(...) {
21996  {
21997 
21998  }
21999  {
22000 
22001  }
22002  {
22003 
22004  }
22005  {
22006  delete [] arg5;
22007  }
22008  throw;
22009  }
22010 }
22011 
22012 
22014  PLINT arg1 ;
22015  PLINT arg2 ;
22016  int val1 ;
22017  int ecode1 = 0 ;
22018  int val2 ;
22019  int ecode2 = 0 ;
22020  octave_value_list _out;
22021  octave_value_list *_outp=&_out;
22022  octave_value _outv;
22023 
22024  try {
22025  if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
22026  SWIG_fail;
22027  }
22028  ecode1 = SWIG_AsVal_int(args(0), &val1);
22029  if (!SWIG_IsOK(ecode1)) {
22030  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
22031  }
22032  arg1 = static_cast< PLINT >(val1);
22033  ecode2 = SWIG_AsVal_int(args(1), &val2);
22034  if (!SWIG_IsOK(ecode2)) {
22035  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
22036  }
22037  arg2 = static_cast< PLINT >(val2);
22038  plprec(arg1,arg2);
22039  _outv = octave_value();
22040  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22041  return _out;
22042  fail:
22043  return octave_value_list();
22044  }
22045  catch(...) {
22046  throw;
22047  }
22048 }
22049 
22050 
22052  PLINT arg1 ;
22053  int val1 ;
22054  int ecode1 = 0 ;
22055  octave_value_list _out;
22056  octave_value_list *_outp=&_out;
22057  octave_value _outv;
22058 
22059  try {
22060  if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
22061  SWIG_fail;
22062  }
22063  ecode1 = SWIG_AsVal_int(args(0), &val1);
22064  if (!SWIG_IsOK(ecode1)) {
22065  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
22066  }
22067  arg1 = static_cast< PLINT >(val1);
22068  plpsty(arg1);
22069  _outv = octave_value();
22070  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22071  return _out;
22072  fail:
22073  return octave_value_list();
22074  }
22075  catch(...) {
22076  throw;
22077  }
22078 }
22079 
22080 
22082  PLFLT arg1 ;
22083  PLFLT arg2 ;
22084  PLFLT arg3 ;
22085  PLFLT arg4 ;
22086  PLFLT arg5 ;
22087  char *arg6 = (char *) 0 ;
22088  double val1 ;
22089  int ecode1 = 0 ;
22090  double val2 ;
22091  int ecode2 = 0 ;
22092  double val3 ;
22093  int ecode3 = 0 ;
22094  double val4 ;
22095  int ecode4 = 0 ;
22096  double val5 ;
22097  int ecode5 = 0 ;
22098  int res6 ;
22099  char *buf6 = 0 ;
22100  int alloc6 = 0 ;
22101  octave_value_list _out;
22102  octave_value_list *_outp=&_out;
22103  octave_value _outv;
22104 
22105  try {
22106  if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
22107  SWIG_fail;
22108  }
22109  ecode1 = SWIG_AsVal_double(args(0), &val1);
22110  if (!SWIG_IsOK(ecode1)) {
22111  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
22112  }
22113  arg1 = static_cast< PLFLT >(val1);
22114  ecode2 = SWIG_AsVal_double(args(1), &val2);
22115  if (!SWIG_IsOK(ecode2)) {
22116  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
22117  }
22118  arg2 = static_cast< PLFLT >(val2);
22119  ecode3 = SWIG_AsVal_double(args(2), &val3);
22120  if (!SWIG_IsOK(ecode3)) {
22121  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
22122  }
22123  arg3 = static_cast< PLFLT >(val3);
22124  ecode4 = SWIG_AsVal_double(args(3), &val4);
22125  if (!SWIG_IsOK(ecode4)) {
22126  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
22127  }
22128  arg4 = static_cast< PLFLT >(val4);
22129  ecode5 = SWIG_AsVal_double(args(4), &val5);
22130  if (!SWIG_IsOK(ecode5)) {
22131  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
22132  }
22133  arg5 = static_cast< PLFLT >(val5);
22134  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
22135  if (!SWIG_IsOK(res6)) {
22136  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
22137  }
22138  arg6 = reinterpret_cast< char * >(buf6);
22139  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
22140  _outv = octave_value();
22141  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22142  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22143  return _out;
22144  fail:
22145  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22146  return octave_value_list();
22147  }
22148  catch(...) {
22149  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
22150  throw;
22151  }
22152 }
22153 
22154 
22156  PLFLT arg1 ;
22157  PLFLT arg2 ;
22158  PLFLT arg3 ;
22159  PLFLT arg4 ;
22160  PLFLT arg5 ;
22161  PLFLT arg6 ;
22162  PLFLT arg7 ;
22163  PLFLT arg8 ;
22164  PLFLT arg9 ;
22165  PLFLT arg10 ;
22166  char *arg11 = (char *) 0 ;
22167  double val1 ;
22168  int ecode1 = 0 ;
22169  double val2 ;
22170  int ecode2 = 0 ;
22171  double val3 ;
22172  int ecode3 = 0 ;
22173  double val4 ;
22174  int ecode4 = 0 ;
22175  double val5 ;
22176  int ecode5 = 0 ;
22177  double val6 ;
22178  int ecode6 = 0 ;
22179  double val7 ;
22180  int ecode7 = 0 ;
22181  double val8 ;
22182  int ecode8 = 0 ;
22183  double val9 ;
22184  int ecode9 = 0 ;
22185  double val10 ;
22186  int ecode10 = 0 ;
22187  int res11 ;
22188  char *buf11 = 0 ;
22189  int alloc11 = 0 ;
22190  octave_value_list _out;
22191  octave_value_list *_outp=&_out;
22192  octave_value _outv;
22193 
22194  try {
22195  if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
22196  SWIG_fail;
22197  }
22198  ecode1 = SWIG_AsVal_double(args(0), &val1);
22199  if (!SWIG_IsOK(ecode1)) {
22200  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
22201  }
22202  arg1 = static_cast< PLFLT >(val1);
22203  ecode2 = SWIG_AsVal_double(args(1), &val2);
22204  if (!SWIG_IsOK(ecode2)) {
22205  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
22206  }
22207  arg2 = static_cast< PLFLT >(val2);
22208  ecode3 = SWIG_AsVal_double(args(2), &val3);
22209  if (!SWIG_IsOK(ecode3)) {
22210  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
22211  }
22212  arg3 = static_cast< PLFLT >(val3);
22213  ecode4 = SWIG_AsVal_double(args(3), &val4);
22214  if (!SWIG_IsOK(ecode4)) {
22215  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
22216  }
22217  arg4 = static_cast< PLFLT >(val4);
22218  ecode5 = SWIG_AsVal_double(args(4), &val5);
22219  if (!SWIG_IsOK(ecode5)) {
22220  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
22221  }
22222  arg5 = static_cast< PLFLT >(val5);
22223  ecode6 = SWIG_AsVal_double(args(5), &val6);
22224  if (!SWIG_IsOK(ecode6)) {
22225  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
22226  }
22227  arg6 = static_cast< PLFLT >(val6);
22228  ecode7 = SWIG_AsVal_double(args(6), &val7);
22229  if (!SWIG_IsOK(ecode7)) {
22230  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
22231  }
22232  arg7 = static_cast< PLFLT >(val7);
22233  ecode8 = SWIG_AsVal_double(args(7), &val8);
22234  if (!SWIG_IsOK(ecode8)) {
22235  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
22236  }
22237  arg8 = static_cast< PLFLT >(val8);
22238  ecode9 = SWIG_AsVal_double(args(8), &val9);
22239  if (!SWIG_IsOK(ecode9)) {
22240  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
22241  }
22242  arg9 = static_cast< PLFLT >(val9);
22243  ecode10 = SWIG_AsVal_double(args(9), &val10);
22244  if (!SWIG_IsOK(ecode10)) {
22245  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
22246  }
22247  arg10 = static_cast< PLFLT >(val10);
22248  res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
22249  if (!SWIG_IsOK(res11)) {
22250  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
22251  }
22252  arg11 = reinterpret_cast< char * >(buf11);
22253  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
22254  _outv = octave_value();
22255  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22256  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22257  return _out;
22258  fail:
22259  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22260  return octave_value_list();
22261  }
22262  catch(...) {
22263  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
22264  throw;
22265  }
22266 }
22267 
22268 
22270  octave_value_list _out;
22271  octave_value_list *_outp=&_out;
22272  octave_value _outv;
22273  PLFLT result;
22274 
22275  try {
22276  if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
22277  SWIG_fail;
22278  }
22279  result = (PLFLT)plrandd();
22280  _outv = SWIG_From_double(static_cast< double >(result));
22281  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22282  return _out;
22283  fail:
22284  return octave_value_list();
22285  }
22286  catch(...) {
22287  throw;
22288  }
22289 }
22290 
22291 
22293  octave_value_list _out;
22294  octave_value_list *_outp=&_out;
22295  octave_value _outv;
22296 
22297  try {
22298  if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
22299  SWIG_fail;
22300  }
22301  plreplot();
22302  _outv = octave_value();
22303  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22304  return _out;
22305  fail:
22306  return octave_value_list();
22307  }
22308  catch(...) {
22309  throw;
22310  }
22311 }
22312 
22313 
22315  PLFLT arg1 ;
22316  PLFLT arg2 ;
22317  PLFLT arg3 ;
22318  PLFLT *arg4 = (PLFLT *) 0 ;
22319  PLFLT *arg5 = (PLFLT *) 0 ;
22320  PLFLT *arg6 = (PLFLT *) 0 ;
22321  double val1 ;
22322  int ecode1 = 0 ;
22323  double val2 ;
22324  int ecode2 = 0 ;
22325  double val3 ;
22326  int ecode3 = 0 ;
22327  PLFLT temp4 ;
22328  int res4 = SWIG_TMPOBJ ;
22329  PLFLT temp5 ;
22330  int res5 = SWIG_TMPOBJ ;
22331  PLFLT temp6 ;
22332  int res6 = SWIG_TMPOBJ ;
22333  octave_value_list _out;
22334  octave_value_list *_outp=&_out;
22335  octave_value _outv;
22336 
22337  try {
22338  arg4 = &temp4;
22339  arg5 = &temp5;
22340  arg6 = &temp6;
22341  if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
22342  SWIG_fail;
22343  }
22344  ecode1 = SWIG_AsVal_double(args(0), &val1);
22345  if (!SWIG_IsOK(ecode1)) {
22346  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
22347  }
22348  arg1 = static_cast< PLFLT >(val1);
22349  ecode2 = SWIG_AsVal_double(args(1), &val2);
22350  if (!SWIG_IsOK(ecode2)) {
22351  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
22352  }
22353  arg2 = static_cast< PLFLT >(val2);
22354  ecode3 = SWIG_AsVal_double(args(2), &val3);
22355  if (!SWIG_IsOK(ecode3)) {
22356  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
22357  }
22358  arg3 = static_cast< PLFLT >(val3);
22359  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
22360  _outv = octave_value();
22361  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22362  if (SWIG_IsTmpObj(res4)) {
22363  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
22364  } else {
22365  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22366  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
22367  }
22368  if (SWIG_IsTmpObj(res5)) {
22369  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
22370  } else {
22371  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22372  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
22373  }
22374  if (SWIG_IsTmpObj(res6)) {
22375  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
22376  } else {
22377  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22378  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
22379  }
22380  return _out;
22381  fail:
22382  return octave_value_list();
22383  }
22384  catch(...) {
22385  throw;
22386  }
22387 }
22388 
22389 
22391  PLFLT arg1 ;
22392  PLFLT arg2 ;
22393  double val1 ;
22394  int ecode1 = 0 ;
22395  double val2 ;
22396  int ecode2 = 0 ;
22397  octave_value_list _out;
22398  octave_value_list *_outp=&_out;
22399  octave_value _outv;
22400 
22401  try {
22402  if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
22403  SWIG_fail;
22404  }
22405  ecode1 = SWIG_AsVal_double(args(0), &val1);
22406  if (!SWIG_IsOK(ecode1)) {
22407  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
22408  }
22409  arg1 = static_cast< PLFLT >(val1);
22410  ecode2 = SWIG_AsVal_double(args(1), &val2);
22411  if (!SWIG_IsOK(ecode2)) {
22412  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
22413  }
22414  arg2 = static_cast< PLFLT >(val2);
22415  plschr(arg1,arg2);
22416  _outv = octave_value();
22417  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22418  return _out;
22419  fail:
22420  return octave_value_list();
22421  }
22422  catch(...) {
22423  throw;
22424  }
22425 }
22426 
22427 
22429  PLINT *arg1 = (PLINT *) 0 ;
22430  PLINT *arg2 = (PLINT *) 0 ;
22431  PLINT *arg3 = (PLINT *) 0 ;
22432  PLINT arg4 ;
22433  Matrix temp1 ;
22434  Matrix temp2 ;
22435  Matrix temp3 ;
22436  octave_value_list _out;
22437  octave_value_list *_outp=&_out;
22438  octave_value _outv;
22439 
22440  try {
22441  if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
22442  SWIG_fail;
22443  }
22444  {
22445  if ( _n_dims( args(0) ) > 1 )
22446  {
22447  error( "argument must be a scalar or vector" ); SWIG_fail;
22448  }
22449  Alen = (PLINT) ( _dim( args(0), 0 ) );
22450  temp1 = args(0).matrix_value();
22451  arg1 = new PLINT[Alen];
22452  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22453  }
22454  {
22455  if ( _n_dims( args(1) ) > 1 )
22456  {
22457  error( "argument must be a scalar or vector" ); SWIG_fail;
22458  }
22459  if ( _dim( args(1), 0 ) != Alen )
22460  {
22461  error( "argument vectors must be same length" ); SWIG_fail;
22462  }
22463  temp2 = args(1).matrix_value();
22464  arg2 = new PLINT[Alen];
22465  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22466  }
22467  {
22468  if ( _n_dims( args(2) ) > 1 )
22469  {
22470  error( "argument must be a scalar or vector" ); SWIG_fail;
22471  }
22472  if ( _dim( args(2), 0 ) != Alen )
22473  {
22474  error( "argument vectors must be same length" ); SWIG_fail;
22475  }
22476  temp3 = args(2).matrix_value();
22477  arg3 = new PLINT[Alen];
22478  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22479  arg4 = Alen;
22480  }
22481  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22482  _outv = octave_value();
22483  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22484  {
22485  delete [] arg1;
22486  }
22487  {
22488  delete [] arg2;
22489  }
22490  {
22491  delete [] arg3;
22492  }
22493  return _out;
22494  fail:
22495  {
22496  delete [] arg1;
22497  }
22498  {
22499  delete [] arg2;
22500  }
22501  {
22502  delete [] arg3;
22503  }
22504  return octave_value_list();
22505  }
22506  catch(...) {
22507  {
22508  delete [] arg1;
22509  }
22510  {
22511  delete [] arg2;
22512  }
22513  {
22514  delete [] arg3;
22515  }
22516  throw;
22517  }
22518 }
22519 
22520 
22522  PLINT *arg1 = (PLINT *) 0 ;
22523  PLINT *arg2 = (PLINT *) 0 ;
22524  PLINT *arg3 = (PLINT *) 0 ;
22525  PLFLT *arg4 = (PLFLT *) 0 ;
22526  PLINT arg5 ;
22527  Matrix temp1 ;
22528  Matrix temp2 ;
22529  Matrix temp3 ;
22530  Matrix temp4 ;
22531  octave_value_list _out;
22532  octave_value_list *_outp=&_out;
22533  octave_value _outv;
22534 
22535  try {
22536  if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
22537  SWIG_fail;
22538  }
22539  {
22540  if ( _n_dims( args(0) ) > 1 )
22541  {
22542  error( "argument must be a scalar or vector" ); SWIG_fail;
22543  }
22544  Alen = (PLINT) ( _dim( args(0), 0 ) );
22545  temp1 = args(0).matrix_value();
22546  arg1 = new PLINT[Alen];
22547  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22548  }
22549  {
22550  if ( _n_dims( args(1) ) > 1 )
22551  {
22552  error( "argument must be a scalar or vector" ); SWIG_fail;
22553  }
22554  if ( _dim( args(1), 0 ) != Alen )
22555  {
22556  error( "argument vectors must be same length" ); SWIG_fail;
22557  }
22558  temp2 = args(1).matrix_value();
22559  arg2 = new PLINT[Alen];
22560  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22561  }
22562  {
22563  if ( _n_dims( args(2) ) > 1 )
22564  {
22565  error( "argument must be a scalar or vector" ); SWIG_fail;
22566  }
22567  if ( _dim( args(2), 0 ) != Alen )
22568  {
22569  error( "argument vectors must be same length" ); SWIG_fail;
22570  }
22571  temp3 = args(2).matrix_value();
22572  arg3 = new PLINT[Alen];
22573  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22574  }
22575  {
22576  if ( _n_dims( args(3) ) > 1 )
22577  {
22578  error( "argument must be a scalar or vector" ); SWIG_fail;
22579  }
22580  if ( _dim( args(3), 0 ) != Alen )
22581  {
22582  error( "argument vectors must be same length" ); SWIG_fail;
22583  }
22584  temp4 = args(3).matrix_value();
22585  arg4 = &temp4( 0, 0 );
22586  arg5 = (PLINT) ( _dim( args(3), 0 ) );
22587  }
22588  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22589  _outv = octave_value();
22590  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22591  {
22592  delete [] arg1;
22593  }
22594  {
22595  delete [] arg2;
22596  }
22597  {
22598  delete [] arg3;
22599  }
22600  {
22601 
22602  }
22603  return _out;
22604  fail:
22605  {
22606  delete [] arg1;
22607  }
22608  {
22609  delete [] arg2;
22610  }
22611  {
22612  delete [] arg3;
22613  }
22614  {
22615 
22616  }
22617  return octave_value_list();
22618  }
22619  catch(...) {
22620  {
22621  delete [] arg1;
22622  }
22623  {
22624  delete [] arg2;
22625  }
22626  {
22627  delete [] arg3;
22628  }
22629  {
22630 
22631  }
22632  throw;
22633  }
22634 }
22635 
22636 
22638  PLINT arg1 ;
22639  int val1 ;
22640  int ecode1 = 0 ;
22641  octave_value_list _out;
22642  octave_value_list *_outp=&_out;
22643  octave_value _outv;
22644 
22645  try {
22646  if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
22647  SWIG_fail;
22648  }
22649  ecode1 = SWIG_AsVal_int(args(0), &val1);
22650  if (!SWIG_IsOK(ecode1)) {
22651  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
22652  }
22653  arg1 = static_cast< PLINT >(val1);
22654  plscmap0n(arg1);
22655  _outv = octave_value();
22656  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22657  return _out;
22658  fail:
22659  return octave_value_list();
22660  }
22661  catch(...) {
22662  throw;
22663  }
22664 }
22665 
22666 
22668  PLINT *arg1 = (PLINT *) 0 ;
22669  PLINT *arg2 = (PLINT *) 0 ;
22670  PLINT *arg3 = (PLINT *) 0 ;
22671  PLINT arg4 ;
22672  Matrix temp1 ;
22673  Matrix temp2 ;
22674  Matrix temp3 ;
22675  octave_value_list _out;
22676  octave_value_list *_outp=&_out;
22677  octave_value _outv;
22678 
22679  try {
22680  if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
22681  SWIG_fail;
22682  }
22683  {
22684  if ( _n_dims( args(0) ) > 1 )
22685  {
22686  error( "argument must be a scalar or vector" ); SWIG_fail;
22687  }
22688  Alen = (PLINT) ( _dim( args(0), 0 ) );
22689  temp1 = args(0).matrix_value();
22690  arg1 = new PLINT[Alen];
22691  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22692  }
22693  {
22694  if ( _n_dims( args(1) ) > 1 )
22695  {
22696  error( "argument must be a scalar or vector" ); SWIG_fail;
22697  }
22698  if ( _dim( args(1), 0 ) != Alen )
22699  {
22700  error( "argument vectors must be same length" ); SWIG_fail;
22701  }
22702  temp2 = args(1).matrix_value();
22703  arg2 = new PLINT[Alen];
22704  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22705  }
22706  {
22707  if ( _n_dims( args(2) ) > 1 )
22708  {
22709  error( "argument must be a scalar or vector" ); SWIG_fail;
22710  }
22711  if ( _dim( args(2), 0 ) != Alen )
22712  {
22713  error( "argument vectors must be same length" ); SWIG_fail;
22714  }
22715  temp3 = args(2).matrix_value();
22716  arg3 = new PLINT[Alen];
22717  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22718  arg4 = Alen;
22719  }
22720  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
22721  _outv = octave_value();
22722  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22723  {
22724  delete [] arg1;
22725  }
22726  {
22727  delete [] arg2;
22728  }
22729  {
22730  delete [] arg3;
22731  }
22732  return _out;
22733  fail:
22734  {
22735  delete [] arg1;
22736  }
22737  {
22738  delete [] arg2;
22739  }
22740  {
22741  delete [] arg3;
22742  }
22743  return octave_value_list();
22744  }
22745  catch(...) {
22746  {
22747  delete [] arg1;
22748  }
22749  {
22750  delete [] arg2;
22751  }
22752  {
22753  delete [] arg3;
22754  }
22755  throw;
22756  }
22757 }
22758 
22759 
22761  PLINT *arg1 = (PLINT *) 0 ;
22762  PLINT *arg2 = (PLINT *) 0 ;
22763  PLINT *arg3 = (PLINT *) 0 ;
22764  PLFLT *arg4 = (PLFLT *) 0 ;
22765  PLINT arg5 ;
22766  Matrix temp1 ;
22767  Matrix temp2 ;
22768  Matrix temp3 ;
22769  Matrix temp4 ;
22770  octave_value_list _out;
22771  octave_value_list *_outp=&_out;
22772  octave_value _outv;
22773 
22774  try {
22775  if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
22776  SWIG_fail;
22777  }
22778  {
22779  if ( _n_dims( args(0) ) > 1 )
22780  {
22781  error( "argument must be a scalar or vector" ); SWIG_fail;
22782  }
22783  Alen = (PLINT) ( _dim( args(0), 0 ) );
22784  temp1 = args(0).matrix_value();
22785  arg1 = new PLINT[Alen];
22786  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
22787  }
22788  {
22789  if ( _n_dims( args(1) ) > 1 )
22790  {
22791  error( "argument must be a scalar or vector" ); SWIG_fail;
22792  }
22793  if ( _dim( args(1), 0 ) != Alen )
22794  {
22795  error( "argument vectors must be same length" ); SWIG_fail;
22796  }
22797  temp2 = args(1).matrix_value();
22798  arg2 = new PLINT[Alen];
22799  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
22800  }
22801  {
22802  if ( _n_dims( args(2) ) > 1 )
22803  {
22804  error( "argument must be a scalar or vector" ); SWIG_fail;
22805  }
22806  if ( _dim( args(2), 0 ) != Alen )
22807  {
22808  error( "argument vectors must be same length" ); SWIG_fail;
22809  }
22810  temp3 = args(2).matrix_value();
22811  arg3 = new PLINT[Alen];
22812  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
22813  }
22814  {
22815  if ( _n_dims( args(3) ) > 1 )
22816  {
22817  error( "argument must be a scalar or vector" ); SWIG_fail;
22818  }
22819  if ( _dim( args(3), 0 ) != Alen )
22820  {
22821  error( "argument vectors must be same length" ); SWIG_fail;
22822  }
22823  temp4 = args(3).matrix_value();
22824  arg4 = &temp4( 0, 0 );
22825  arg5 = (PLINT) ( _dim( args(3), 0 ) );
22826  }
22827  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
22828  _outv = octave_value();
22829  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22830  {
22831  delete [] arg1;
22832  }
22833  {
22834  delete [] arg2;
22835  }
22836  {
22837  delete [] arg3;
22838  }
22839  {
22840 
22841  }
22842  return _out;
22843  fail:
22844  {
22845  delete [] arg1;
22846  }
22847  {
22848  delete [] arg2;
22849  }
22850  {
22851  delete [] arg3;
22852  }
22853  {
22854 
22855  }
22856  return octave_value_list();
22857  }
22858  catch(...) {
22859  {
22860  delete [] arg1;
22861  }
22862  {
22863  delete [] arg2;
22864  }
22865  {
22866  delete [] arg3;
22867  }
22868  {
22869 
22870  }
22871  throw;
22872  }
22873 }
22874 
22875 
22877  PLBOOL arg1 ;
22878  PLINT arg2 ;
22879  PLFLT *arg3 = (PLFLT *) 0 ;
22880  PLFLT *arg4 = (PLFLT *) 0 ;
22881  PLFLT *arg5 = (PLFLT *) 0 ;
22882  PLFLT *arg6 = (PLFLT *) 0 ;
22883  PLBOOL *arg7 = (PLBOOL *) 0 ;
22884  int val1 ;
22885  int ecode1 = 0 ;
22886  Matrix temp2 ;
22887  Matrix temp4 ;
22888  Matrix temp5 ;
22889  Matrix temp6 ;
22890  Matrix temp7 ;
22891  octave_value_list _out;
22892  octave_value_list *_outp=&_out;
22893  octave_value _outv;
22894 
22895  try {
22896  if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
22897  SWIG_fail;
22898  }
22899  ecode1 = SWIG_AsVal_int(args(0), &val1);
22900  if (!SWIG_IsOK(ecode1)) {
22901  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
22902  }
22903  arg1 = static_cast< PLBOOL >(val1);
22904  {
22905  if ( _n_dims( args(1) ) > 1 )
22906  {
22907  error( "argument must be a scalar or vector" ); SWIG_fail;
22908  }
22909  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
22910  temp2 = args(1).matrix_value();
22911  arg3 = &temp2( 0, 0 );
22912  }
22913  {
22914  if ( _n_dims( args(2) ) > 1 )
22915  {
22916  error( "argument must be a scalar or vector" ); SWIG_fail;
22917  }
22918  if ( _dim( args(2), 0 ) != Alen )
22919  {
22920  error( "argument vectors must be same length" ); SWIG_fail;
22921  }
22922  temp4 = args(2).matrix_value();
22923  arg4 = &temp4( 0, 0 );
22924  }
22925  {
22926  if ( _n_dims( args(3) ) > 1 )
22927  {
22928  error( "argument must be a scalar or vector" ); SWIG_fail;
22929  }
22930  if ( _dim( args(3), 0 ) != Alen )
22931  {
22932  error( "argument vectors must be same length" ); SWIG_fail;
22933  }
22934  temp5 = args(3).matrix_value();
22935  arg5 = &temp5( 0, 0 );
22936  }
22937  {
22938  if ( _n_dims( args(4) ) > 1 )
22939  {
22940  error( "argument must be a scalar or vector" ); SWIG_fail;
22941  }
22942  if ( _dim( args(4), 0 ) != Alen )
22943  {
22944  error( "argument vectors must be same length" ); SWIG_fail;
22945  }
22946  temp6 = args(4).matrix_value();
22947  arg6 = &temp6( 0, 0 );
22948  }
22949  {
22950  if ( _n_dims( args(5) ) > 1 )
22951  {
22952  error( "argument must be a scalar or vector" ); SWIG_fail;
22953  }
22954  if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
22955  {
22956  error( "argument vector must be same length or one less" ); SWIG_fail;
22957  }
22958  temp7 = args(5).matrix_value();
22959  arg7 = new PLINT[Alen];
22960  _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
22961  }
22962  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
22963  _outv = octave_value();
22964  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22965  {
22966 
22967  }
22968  {
22969 
22970  }
22971  {
22972 
22973  }
22974  {
22975 
22976  }
22977  {
22978  delete [] arg7;
22979  }
22980  return _out;
22981  fail:
22982  {
22983 
22984  }
22985  {
22986 
22987  }
22988  {
22989 
22990  }
22991  {
22992 
22993  }
22994  {
22995  delete [] arg7;
22996  }
22997  return octave_value_list();
22998  }
22999  catch(...) {
23000  {
23001 
23002  }
23003  {
23004 
23005  }
23006  {
23007 
23008  }
23009  {
23010 
23011  }
23012  {
23013  delete [] arg7;
23014  }
23015  throw;
23016  }
23017 }
23018 
23019 
23021  PLBOOL arg1 ;
23022  PLINT arg2 ;
23023  PLFLT *arg3 = (PLFLT *) 0 ;
23024  PLFLT *arg4 = (PLFLT *) 0 ;
23025  PLFLT *arg5 = (PLFLT *) 0 ;
23026  PLFLT *arg6 = (PLFLT *) 0 ;
23027  PLFLT *arg7 = (PLFLT *) 0 ;
23028  PLBOOL *arg8 = (PLBOOL *) 0 ;
23029  int val1 ;
23030  int ecode1 = 0 ;
23031  Matrix temp2 ;
23032  Matrix temp4 ;
23033  Matrix temp5 ;
23034  Matrix temp6 ;
23035  Matrix temp7 ;
23036  Matrix temp8 ;
23037  octave_value_list _out;
23038  octave_value_list *_outp=&_out;
23039  octave_value _outv;
23040 
23041  try {
23042  if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
23043  SWIG_fail;
23044  }
23045  ecode1 = SWIG_AsVal_int(args(0), &val1);
23046  if (!SWIG_IsOK(ecode1)) {
23047  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
23048  }
23049  arg1 = static_cast< PLBOOL >(val1);
23050  {
23051  if ( _n_dims( args(1) ) > 1 )
23052  {
23053  error( "argument must be a scalar or vector" ); SWIG_fail;
23054  }
23055  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
23056  temp2 = args(1).matrix_value();
23057  arg3 = &temp2( 0, 0 );
23058  }
23059  {
23060  if ( _n_dims( args(2) ) > 1 )
23061  {
23062  error( "argument must be a scalar or vector" ); SWIG_fail;
23063  }
23064  if ( _dim( args(2), 0 ) != Alen )
23065  {
23066  error( "argument vectors must be same length" ); SWIG_fail;
23067  }
23068  temp4 = args(2).matrix_value();
23069  arg4 = &temp4( 0, 0 );
23070  }
23071  {
23072  if ( _n_dims( args(3) ) > 1 )
23073  {
23074  error( "argument must be a scalar or vector" ); SWIG_fail;
23075  }
23076  if ( _dim( args(3), 0 ) != Alen )
23077  {
23078  error( "argument vectors must be same length" ); SWIG_fail;
23079  }
23080  temp5 = args(3).matrix_value();
23081  arg5 = &temp5( 0, 0 );
23082  }
23083  {
23084  if ( _n_dims( args(4) ) > 1 )
23085  {
23086  error( "argument must be a scalar or vector" ); SWIG_fail;
23087  }
23088  if ( _dim( args(4), 0 ) != Alen )
23089  {
23090  error( "argument vectors must be same length" ); SWIG_fail;
23091  }
23092  temp6 = args(4).matrix_value();
23093  arg6 = &temp6( 0, 0 );
23094  }
23095  {
23096  if ( _n_dims( args(5) ) > 1 )
23097  {
23098  error( "argument must be a scalar or vector" ); SWIG_fail;
23099  }
23100  if ( _dim( args(5), 0 ) != Alen )
23101  {
23102  error( "argument vectors must be same length" ); SWIG_fail;
23103  }
23104  temp7 = args(5).matrix_value();
23105  arg7 = &temp7( 0, 0 );
23106  }
23107  {
23108  if ( _n_dims( args(6) ) > 1 )
23109  {
23110  error( "argument must be a scalar or vector" ); SWIG_fail;
23111  }
23112  if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
23113  {
23114  error( "argument vector must be same length or one less" ); SWIG_fail;
23115  }
23116  temp8 = args(6).matrix_value();
23117  arg8 = new PLINT[Alen];
23118  _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
23119  }
23120  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
23121  _outv = octave_value();
23122  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23123  {
23124 
23125  }
23126  {
23127 
23128  }
23129  {
23130 
23131  }
23132  {
23133 
23134  }
23135  {
23136 
23137  }
23138  {
23139  delete [] arg8;
23140  }
23141  return _out;
23142  fail:
23143  {
23144 
23145  }
23146  {
23147 
23148  }
23149  {
23150 
23151  }
23152  {
23153 
23154  }
23155  {
23156 
23157  }
23158  {
23159  delete [] arg8;
23160  }
23161  return octave_value_list();
23162  }
23163  catch(...) {
23164  {
23165 
23166  }
23167  {
23168 
23169  }
23170  {
23171 
23172  }
23173  {
23174 
23175  }
23176  {
23177 
23178  }
23179  {
23180  delete [] arg8;
23181  }
23182  throw;
23183  }
23184 }
23185 
23186 
23188  PLINT arg1 ;
23189  int val1 ;
23190  int ecode1 = 0 ;
23191  octave_value_list _out;
23192  octave_value_list *_outp=&_out;
23193  octave_value _outv;
23194 
23195  try {
23196  if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
23197  SWIG_fail;
23198  }
23199  ecode1 = SWIG_AsVal_int(args(0), &val1);
23200  if (!SWIG_IsOK(ecode1)) {
23201  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
23202  }
23203  arg1 = static_cast< PLINT >(val1);
23204  plscmap1n(arg1);
23205  _outv = octave_value();
23206  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23207  return _out;
23208  fail:
23209  return octave_value_list();
23210  }
23211  catch(...) {
23212  throw;
23213  }
23214 }
23215 
23216 
23218  PLFLT arg1 ;
23219  PLFLT arg2 ;
23220  double val1 ;
23221  int ecode1 = 0 ;
23222  double val2 ;
23223  int ecode2 = 0 ;
23224  octave_value_list _out;
23225  octave_value_list *_outp=&_out;
23226  octave_value _outv;
23227 
23228  try {
23229  if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
23230  SWIG_fail;
23231  }
23232  ecode1 = SWIG_AsVal_double(args(0), &val1);
23233  if (!SWIG_IsOK(ecode1)) {
23234  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
23235  }
23236  arg1 = static_cast< PLFLT >(val1);
23237  ecode2 = SWIG_AsVal_double(args(1), &val2);
23238  if (!SWIG_IsOK(ecode2)) {
23239  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
23240  }
23241  arg2 = static_cast< PLFLT >(val2);
23242  plscmap1_range(arg1,arg2);
23243  _outv = octave_value();
23244  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23245  return _out;
23246  fail:
23247  return octave_value_list();
23248  }
23249  catch(...) {
23250  throw;
23251  }
23252 }
23253 
23254 
23256  PLFLT *arg1 = (PLFLT *) 0 ;
23257  PLFLT *arg2 = (PLFLT *) 0 ;
23258  PLFLT temp1 ;
23259  int res1 = SWIG_TMPOBJ ;
23260  PLFLT temp2 ;
23261  int res2 = SWIG_TMPOBJ ;
23262  octave_value_list _out;
23263  octave_value_list *_outp=&_out;
23264  octave_value _outv;
23265 
23266  try {
23267  arg1 = &temp1;
23268  arg2 = &temp2;
23269  if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
23270  SWIG_fail;
23271  }
23272  plgcmap1_range(arg1,arg2);
23273  _outv = octave_value();
23274  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23275  if (SWIG_IsTmpObj(res1)) {
23276  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
23277  } else {
23278  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23279  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
23280  }
23281  if (SWIG_IsTmpObj(res2)) {
23282  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
23283  } else {
23284  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23285  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
23286  }
23287  return _out;
23288  fail:
23289  return octave_value_list();
23290  }
23291  catch(...) {
23292  throw;
23293  }
23294 }
23295 
23296 
23298  PLINT arg1 ;
23299  PLINT arg2 ;
23300  PLINT arg3 ;
23301  PLINT arg4 ;
23302  int val1 ;
23303  int ecode1 = 0 ;
23304  int val2 ;
23305  int ecode2 = 0 ;
23306  int val3 ;
23307  int ecode3 = 0 ;
23308  int val4 ;
23309  int ecode4 = 0 ;
23310  octave_value_list _out;
23311  octave_value_list *_outp=&_out;
23312  octave_value _outv;
23313 
23314  try {
23315  if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
23316  SWIG_fail;
23317  }
23318  ecode1 = SWIG_AsVal_int(args(0), &val1);
23319  if (!SWIG_IsOK(ecode1)) {
23320  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
23321  }
23322  arg1 = static_cast< PLINT >(val1);
23323  ecode2 = SWIG_AsVal_int(args(1), &val2);
23324  if (!SWIG_IsOK(ecode2)) {
23325  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
23326  }
23327  arg2 = static_cast< PLINT >(val2);
23328  ecode3 = SWIG_AsVal_int(args(2), &val3);
23329  if (!SWIG_IsOK(ecode3)) {
23330  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
23331  }
23332  arg3 = static_cast< PLINT >(val3);
23333  ecode4 = SWIG_AsVal_int(args(3), &val4);
23334  if (!SWIG_IsOK(ecode4)) {
23335  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
23336  }
23337  arg4 = static_cast< PLINT >(val4);
23338  plscol0(arg1,arg2,arg3,arg4);
23339  _outv = octave_value();
23340  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23341  return _out;
23342  fail:
23343  return octave_value_list();
23344  }
23345  catch(...) {
23346  throw;
23347  }
23348 }
23349 
23350 
23352  PLINT arg1 ;
23353  PLINT arg2 ;
23354  PLINT arg3 ;
23355  PLINT arg4 ;
23356  PLFLT arg5 ;
23357  int val1 ;
23358  int ecode1 = 0 ;
23359  int val2 ;
23360  int ecode2 = 0 ;
23361  int val3 ;
23362  int ecode3 = 0 ;
23363  int val4 ;
23364  int ecode4 = 0 ;
23365  double val5 ;
23366  int ecode5 = 0 ;
23367  octave_value_list _out;
23368  octave_value_list *_outp=&_out;
23369  octave_value _outv;
23370 
23371  try {
23372  if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
23373  SWIG_fail;
23374  }
23375  ecode1 = SWIG_AsVal_int(args(0), &val1);
23376  if (!SWIG_IsOK(ecode1)) {
23377  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
23378  }
23379  arg1 = static_cast< PLINT >(val1);
23380  ecode2 = SWIG_AsVal_int(args(1), &val2);
23381  if (!SWIG_IsOK(ecode2)) {
23382  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
23383  }
23384  arg2 = static_cast< PLINT >(val2);
23385  ecode3 = SWIG_AsVal_int(args(2), &val3);
23386  if (!SWIG_IsOK(ecode3)) {
23387  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
23388  }
23389  arg3 = static_cast< PLINT >(val3);
23390  ecode4 = SWIG_AsVal_int(args(3), &val4);
23391  if (!SWIG_IsOK(ecode4)) {
23392  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
23393  }
23394  arg4 = static_cast< PLINT >(val4);
23395  ecode5 = SWIG_AsVal_double(args(4), &val5);
23396  if (!SWIG_IsOK(ecode5)) {
23397  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
23398  }
23399  arg5 = static_cast< PLFLT >(val5);
23400  plscol0a(arg1,arg2,arg3,arg4,arg5);
23401  _outv = octave_value();
23402  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23403  return _out;
23404  fail:
23405  return octave_value_list();
23406  }
23407  catch(...) {
23408  throw;
23409  }
23410 }
23411 
23412 
23414  PLINT arg1 ;
23415  PLINT arg2 ;
23416  PLINT arg3 ;
23417  int val1 ;
23418  int ecode1 = 0 ;
23419  int val2 ;
23420  int ecode2 = 0 ;
23421  int val3 ;
23422  int ecode3 = 0 ;
23423  octave_value_list _out;
23424  octave_value_list *_outp=&_out;
23425  octave_value _outv;
23426 
23427  try {
23428  if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
23429  SWIG_fail;
23430  }
23431  ecode1 = SWIG_AsVal_int(args(0), &val1);
23432  if (!SWIG_IsOK(ecode1)) {
23433  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
23434  }
23435  arg1 = static_cast< PLINT >(val1);
23436  ecode2 = SWIG_AsVal_int(args(1), &val2);
23437  if (!SWIG_IsOK(ecode2)) {
23438  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
23439  }
23440  arg2 = static_cast< PLINT >(val2);
23441  ecode3 = SWIG_AsVal_int(args(2), &val3);
23442  if (!SWIG_IsOK(ecode3)) {
23443  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
23444  }
23445  arg3 = static_cast< PLINT >(val3);
23446  plscolbg(arg1,arg2,arg3);
23447  _outv = octave_value();
23448  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23449  return _out;
23450  fail:
23451  return octave_value_list();
23452  }
23453  catch(...) {
23454  throw;
23455  }
23456 }
23457 
23458 
23460  PLINT arg1 ;
23461  PLINT arg2 ;
23462  PLINT arg3 ;
23463  PLFLT arg4 ;
23464  int val1 ;
23465  int ecode1 = 0 ;
23466  int val2 ;
23467  int ecode2 = 0 ;
23468  int val3 ;
23469  int ecode3 = 0 ;
23470  double val4 ;
23471  int ecode4 = 0 ;
23472  octave_value_list _out;
23473  octave_value_list *_outp=&_out;
23474  octave_value _outv;
23475 
23476  try {
23477  if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
23478  SWIG_fail;
23479  }
23480  ecode1 = SWIG_AsVal_int(args(0), &val1);
23481  if (!SWIG_IsOK(ecode1)) {
23482  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
23483  }
23484  arg1 = static_cast< PLINT >(val1);
23485  ecode2 = SWIG_AsVal_int(args(1), &val2);
23486  if (!SWIG_IsOK(ecode2)) {
23487  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
23488  }
23489  arg2 = static_cast< PLINT >(val2);
23490  ecode3 = SWIG_AsVal_int(args(2), &val3);
23491  if (!SWIG_IsOK(ecode3)) {
23492  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
23493  }
23494  arg3 = static_cast< PLINT >(val3);
23495  ecode4 = SWIG_AsVal_double(args(3), &val4);
23496  if (!SWIG_IsOK(ecode4)) {
23497  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
23498  }
23499  arg4 = static_cast< PLFLT >(val4);
23500  plscolbga(arg1,arg2,arg3,arg4);
23501  _outv = octave_value();
23502  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23503  return _out;
23504  fail:
23505  return octave_value_list();
23506  }
23507  catch(...) {
23508  throw;
23509  }
23510 }
23511 
23512 
23514  PLINT arg1 ;
23515  int val1 ;
23516  int ecode1 = 0 ;
23517  octave_value_list _out;
23518  octave_value_list *_outp=&_out;
23519  octave_value _outv;
23520 
23521  try {
23522  if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
23523  SWIG_fail;
23524  }
23525  ecode1 = SWIG_AsVal_int(args(0), &val1);
23526  if (!SWIG_IsOK(ecode1)) {
23527  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
23528  }
23529  arg1 = static_cast< PLINT >(val1);
23530  plscolor(arg1);
23531  _outv = octave_value();
23532  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23533  return _out;
23534  fail:
23535  return octave_value_list();
23536  }
23537  catch(...) {
23538  throw;
23539  }
23540 }
23541 
23542 
23544  PLINT arg1 ;
23545  int val1 ;
23546  int ecode1 = 0 ;
23547  octave_value_list _out;
23548  octave_value_list *_outp=&_out;
23549  octave_value _outv;
23550 
23551  try {
23552  if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
23553  SWIG_fail;
23554  }
23555  ecode1 = SWIG_AsVal_int(args(0), &val1);
23556  if (!SWIG_IsOK(ecode1)) {
23557  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
23558  }
23559  arg1 = static_cast< PLINT >(val1);
23560  plscompression(arg1);
23561  _outv = octave_value();
23562  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23563  return _out;
23564  fail:
23565  return octave_value_list();
23566  }
23567  catch(...) {
23568  throw;
23569  }
23570 }
23571 
23572 
23574  char *arg1 = (char *) 0 ;
23575  int res1 ;
23576  char *buf1 = 0 ;
23577  int alloc1 = 0 ;
23578  octave_value_list _out;
23579  octave_value_list *_outp=&_out;
23580  octave_value _outv;
23581 
23582  try {
23583  if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
23584  SWIG_fail;
23585  }
23586  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23587  if (!SWIG_IsOK(res1)) {
23588  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
23589  }
23590  arg1 = reinterpret_cast< char * >(buf1);
23591  plsdev((char const *)arg1);
23592  _outv = octave_value();
23593  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23594  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23595  return _out;
23596  fail:
23597  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23598  return octave_value_list();
23599  }
23600  catch(...) {
23601  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23602  throw;
23603  }
23604 }
23605 
23606 
23608  PLFLT arg1 ;
23609  PLFLT arg2 ;
23610  PLFLT arg3 ;
23611  PLFLT arg4 ;
23612  double val1 ;
23613  int ecode1 = 0 ;
23614  double val2 ;
23615  int ecode2 = 0 ;
23616  double val3 ;
23617  int ecode3 = 0 ;
23618  double val4 ;
23619  int ecode4 = 0 ;
23620  octave_value_list _out;
23621  octave_value_list *_outp=&_out;
23622  octave_value _outv;
23623 
23624  try {
23625  if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
23626  SWIG_fail;
23627  }
23628  ecode1 = SWIG_AsVal_double(args(0), &val1);
23629  if (!SWIG_IsOK(ecode1)) {
23630  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
23631  }
23632  arg1 = static_cast< PLFLT >(val1);
23633  ecode2 = SWIG_AsVal_double(args(1), &val2);
23634  if (!SWIG_IsOK(ecode2)) {
23635  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
23636  }
23637  arg2 = static_cast< PLFLT >(val2);
23638  ecode3 = SWIG_AsVal_double(args(2), &val3);
23639  if (!SWIG_IsOK(ecode3)) {
23640  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
23641  }
23642  arg3 = static_cast< PLFLT >(val3);
23643  ecode4 = SWIG_AsVal_double(args(3), &val4);
23644  if (!SWIG_IsOK(ecode4)) {
23645  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
23646  }
23647  arg4 = static_cast< PLFLT >(val4);
23648  plsdidev(arg1,arg2,arg3,arg4);
23649  _outv = octave_value();
23650  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23651  return _out;
23652  fail:
23653  return octave_value_list();
23654  }
23655  catch(...) {
23656  throw;
23657  }
23658 }
23659 
23660 
23662  PLINT arg1 ;
23663  PLINT arg2 ;
23664  PLINT arg3 ;
23665  PLINT arg4 ;
23666  PLFLT arg5 ;
23667  PLFLT arg6 ;
23668  int val1 ;
23669  int ecode1 = 0 ;
23670  int val2 ;
23671  int ecode2 = 0 ;
23672  int val3 ;
23673  int ecode3 = 0 ;
23674  int val4 ;
23675  int ecode4 = 0 ;
23676  double val5 ;
23677  int ecode5 = 0 ;
23678  double val6 ;
23679  int ecode6 = 0 ;
23680  octave_value_list _out;
23681  octave_value_list *_outp=&_out;
23682  octave_value _outv;
23683 
23684  try {
23685  if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
23686  SWIG_fail;
23687  }
23688  ecode1 = SWIG_AsVal_int(args(0), &val1);
23689  if (!SWIG_IsOK(ecode1)) {
23690  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
23691  }
23692  arg1 = static_cast< PLINT >(val1);
23693  ecode2 = SWIG_AsVal_int(args(1), &val2);
23694  if (!SWIG_IsOK(ecode2)) {
23695  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
23696  }
23697  arg2 = static_cast< PLINT >(val2);
23698  ecode3 = SWIG_AsVal_int(args(2), &val3);
23699  if (!SWIG_IsOK(ecode3)) {
23700  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
23701  }
23702  arg3 = static_cast< PLINT >(val3);
23703  ecode4 = SWIG_AsVal_int(args(3), &val4);
23704  if (!SWIG_IsOK(ecode4)) {
23705  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
23706  }
23707  arg4 = static_cast< PLINT >(val4);
23708  ecode5 = SWIG_AsVal_double(args(4), &val5);
23709  if (!SWIG_IsOK(ecode5)) {
23710  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
23711  }
23712  arg5 = static_cast< PLFLT >(val5);
23713  ecode6 = SWIG_AsVal_double(args(5), &val6);
23714  if (!SWIG_IsOK(ecode6)) {
23715  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
23716  }
23717  arg6 = static_cast< PLFLT >(val6);
23718  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
23719  _outv = octave_value();
23720  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23721  return _out;
23722  fail:
23723  return octave_value_list();
23724  }
23725  catch(...) {
23726  throw;
23727  }
23728 }
23729 
23730 
23732  PLFLT arg1 ;
23733  double val1 ;
23734  int ecode1 = 0 ;
23735  octave_value_list _out;
23736  octave_value_list *_outp=&_out;
23737  octave_value _outv;
23738 
23739  try {
23740  if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
23741  SWIG_fail;
23742  }
23743  ecode1 = SWIG_AsVal_double(args(0), &val1);
23744  if (!SWIG_IsOK(ecode1)) {
23745  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
23746  }
23747  arg1 = static_cast< PLFLT >(val1);
23748  plsdiori(arg1);
23749  _outv = octave_value();
23750  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23751  return _out;
23752  fail:
23753  return octave_value_list();
23754  }
23755  catch(...) {
23756  throw;
23757  }
23758 }
23759 
23760 
23762  PLFLT arg1 ;
23763  PLFLT arg2 ;
23764  PLFLT arg3 ;
23765  PLFLT arg4 ;
23766  double val1 ;
23767  int ecode1 = 0 ;
23768  double val2 ;
23769  int ecode2 = 0 ;
23770  double val3 ;
23771  int ecode3 = 0 ;
23772  double val4 ;
23773  int ecode4 = 0 ;
23774  octave_value_list _out;
23775  octave_value_list *_outp=&_out;
23776  octave_value _outv;
23777 
23778  try {
23779  if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
23780  SWIG_fail;
23781  }
23782  ecode1 = SWIG_AsVal_double(args(0), &val1);
23783  if (!SWIG_IsOK(ecode1)) {
23784  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
23785  }
23786  arg1 = static_cast< PLFLT >(val1);
23787  ecode2 = SWIG_AsVal_double(args(1), &val2);
23788  if (!SWIG_IsOK(ecode2)) {
23789  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
23790  }
23791  arg2 = static_cast< PLFLT >(val2);
23792  ecode3 = SWIG_AsVal_double(args(2), &val3);
23793  if (!SWIG_IsOK(ecode3)) {
23794  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
23795  }
23796  arg3 = static_cast< PLFLT >(val3);
23797  ecode4 = SWIG_AsVal_double(args(3), &val4);
23798  if (!SWIG_IsOK(ecode4)) {
23799  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
23800  }
23801  arg4 = static_cast< PLFLT >(val4);
23802  plsdiplt(arg1,arg2,arg3,arg4);
23803  _outv = octave_value();
23804  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23805  return _out;
23806  fail:
23807  return octave_value_list();
23808  }
23809  catch(...) {
23810  throw;
23811  }
23812 }
23813 
23814 
23816  PLFLT arg1 ;
23817  PLFLT arg2 ;
23818  PLFLT arg3 ;
23819  PLFLT arg4 ;
23820  double val1 ;
23821  int ecode1 = 0 ;
23822  double val2 ;
23823  int ecode2 = 0 ;
23824  double val3 ;
23825  int ecode3 = 0 ;
23826  double val4 ;
23827  int ecode4 = 0 ;
23828  octave_value_list _out;
23829  octave_value_list *_outp=&_out;
23830  octave_value _outv;
23831 
23832  try {
23833  if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
23834  SWIG_fail;
23835  }
23836  ecode1 = SWIG_AsVal_double(args(0), &val1);
23837  if (!SWIG_IsOK(ecode1)) {
23838  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
23839  }
23840  arg1 = static_cast< PLFLT >(val1);
23841  ecode2 = SWIG_AsVal_double(args(1), &val2);
23842  if (!SWIG_IsOK(ecode2)) {
23843  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
23844  }
23845  arg2 = static_cast< PLFLT >(val2);
23846  ecode3 = SWIG_AsVal_double(args(2), &val3);
23847  if (!SWIG_IsOK(ecode3)) {
23848  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
23849  }
23850  arg3 = static_cast< PLFLT >(val3);
23851  ecode4 = SWIG_AsVal_double(args(3), &val4);
23852  if (!SWIG_IsOK(ecode4)) {
23853  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
23854  }
23855  arg4 = static_cast< PLFLT >(val4);
23856  plsdiplz(arg1,arg2,arg3,arg4);
23857  _outv = octave_value();
23858  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23859  return _out;
23860  fail:
23861  return octave_value_list();
23862  }
23863  catch(...) {
23864  throw;
23865  }
23866 }
23867 
23868 
23870  unsigned int arg1 ;
23871  unsigned int val1 ;
23872  int ecode1 = 0 ;
23873  octave_value_list _out;
23874  octave_value_list *_outp=&_out;
23875  octave_value _outv;
23876 
23877  try {
23878  if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
23879  SWIG_fail;
23880  }
23881  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
23882  if (!SWIG_IsOK(ecode1)) {
23883  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
23884  }
23885  arg1 = static_cast< unsigned int >(val1);
23886  plseed(arg1);
23887  _outv = octave_value();
23888  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23889  return _out;
23890  fail:
23891  return octave_value_list();
23892  }
23893  catch(...) {
23894  throw;
23895  }
23896 }
23897 
23898 
23900  char arg1 ;
23901  char val1 ;
23902  int ecode1 = 0 ;
23903  octave_value_list _out;
23904  octave_value_list *_outp=&_out;
23905  octave_value _outv;
23906 
23907  try {
23908  if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
23909  SWIG_fail;
23910  }
23911  ecode1 = SWIG_AsVal_char(args(0), &val1);
23912  if (!SWIG_IsOK(ecode1)) {
23913  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
23914  }
23915  arg1 = static_cast< char >(val1);
23916  plsesc(arg1);
23917  _outv = octave_value();
23918  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23919  return _out;
23920  fail:
23921  return octave_value_list();
23922  }
23923  catch(...) {
23924  throw;
23925  }
23926 }
23927 
23928 
23929 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
23930  char *arg1 = (char *) 0 ;
23931  char *arg2 = (char *) 0 ;
23932  int res1 ;
23933  char *buf1 = 0 ;
23934  int alloc1 = 0 ;
23935  int res2 ;
23936  char *buf2 = 0 ;
23937  int alloc2 = 0 ;
23938  octave_value_list _out;
23939  octave_value_list *_outp=&_out;
23940  octave_value _outv;
23941  PLINT result;
23942 
23943  try {
23944  if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
23945  SWIG_fail;
23946  }
23947  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23948  if (!SWIG_IsOK(res1)) {
23949  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
23950  }
23951  arg1 = reinterpret_cast< char * >(buf1);
23952  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
23953  if (!SWIG_IsOK(res2)) {
23954  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
23955  }
23956  arg2 = reinterpret_cast< char * >(buf2);
23957  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
23958  _outv = SWIG_From_int(static_cast< int >(result));
23959  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23960  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23961  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23962  return _out;
23963  fail:
23964  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23965  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23966  return octave_value_list();
23967  }
23968  catch(...) {
23969  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23970  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
23971  throw;
23972  }
23973 }
23974 
23975 
23977  PLINT arg1 ;
23978  PLINT arg2 ;
23979  PLINT arg3 ;
23980  int val1 ;
23981  int ecode1 = 0 ;
23982  int val2 ;
23983  int ecode2 = 0 ;
23984  int val3 ;
23985  int ecode3 = 0 ;
23986  octave_value_list _out;
23987  octave_value_list *_outp=&_out;
23988  octave_value _outv;
23989 
23990  try {
23991  if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
23992  SWIG_fail;
23993  }
23994  ecode1 = SWIG_AsVal_int(args(0), &val1);
23995  if (!SWIG_IsOK(ecode1)) {
23996  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
23997  }
23998  arg1 = static_cast< PLINT >(val1);
23999  ecode2 = SWIG_AsVal_int(args(1), &val2);
24000  if (!SWIG_IsOK(ecode2)) {
24001  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
24002  }
24003  arg2 = static_cast< PLINT >(val2);
24004  ecode3 = SWIG_AsVal_int(args(2), &val3);
24005  if (!SWIG_IsOK(ecode3)) {
24006  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
24007  }
24008  arg3 = static_cast< PLINT >(val3);
24009  plsfam(arg1,arg2,arg3);
24010  _outv = octave_value();
24011  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24012  return _out;
24013  fail:
24014  return octave_value_list();
24015  }
24016  catch(...) {
24017  throw;
24018  }
24019 }
24020 
24021 
24023  PLUNICODE arg1 ;
24024  unsigned int val1 ;
24025  int ecode1 = 0 ;
24026  octave_value_list _out;
24027  octave_value_list *_outp=&_out;
24028  octave_value _outv;
24029 
24030  try {
24031  if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
24032  SWIG_fail;
24033  }
24034  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
24035  if (!SWIG_IsOK(ecode1)) {
24036  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
24037  }
24038  arg1 = static_cast< PLUNICODE >(val1);
24039  plsfci(arg1);
24040  _outv = octave_value();
24041  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24042  return _out;
24043  fail:
24044  return octave_value_list();
24045  }
24046  catch(...) {
24047  throw;
24048  }
24049 }
24050 
24051 
24053  char *arg1 = (char *) 0 ;
24054  int res1 ;
24055  char *buf1 = 0 ;
24056  int alloc1 = 0 ;
24057  octave_value_list _out;
24058  octave_value_list *_outp=&_out;
24059  octave_value _outv;
24060 
24061  try {
24062  if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
24063  SWIG_fail;
24064  }
24065  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24066  if (!SWIG_IsOK(res1)) {
24067  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
24068  }
24069  arg1 = reinterpret_cast< char * >(buf1);
24070  plsfnam((char const *)arg1);
24071  _outv = octave_value();
24072  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24073  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24074  return _out;
24075  fail:
24076  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24077  return octave_value_list();
24078  }
24079  catch(...) {
24080  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24081  throw;
24082  }
24083 }
24084 
24085 
24087  PLINT arg1 ;
24088  PLINT arg2 ;
24089  PLINT arg3 ;
24090  int val1 ;
24091  int ecode1 = 0 ;
24092  int val2 ;
24093  int ecode2 = 0 ;
24094  int val3 ;
24095  int ecode3 = 0 ;
24096  octave_value_list _out;
24097  octave_value_list *_outp=&_out;
24098  octave_value _outv;
24099 
24100  try {
24101  if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
24102  SWIG_fail;
24103  }
24104  ecode1 = SWIG_AsVal_int(args(0), &val1);
24105  if (!SWIG_IsOK(ecode1)) {
24106  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
24107  }
24108  arg1 = static_cast< PLINT >(val1);
24109  ecode2 = SWIG_AsVal_int(args(1), &val2);
24110  if (!SWIG_IsOK(ecode2)) {
24111  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
24112  }
24113  arg2 = static_cast< PLINT >(val2);
24114  ecode3 = SWIG_AsVal_int(args(2), &val3);
24115  if (!SWIG_IsOK(ecode3)) {
24116  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
24117  }
24118  arg3 = static_cast< PLINT >(val3);
24119  plsfont(arg1,arg2,arg3);
24120  _outv = octave_value();
24121  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24122  return _out;
24123  fail:
24124  return octave_value_list();
24125  }
24126  catch(...) {
24127  throw;
24128  }
24129 }
24130 
24131 
24133  label_func arg1 = (label_func) 0 ;
24134  PLPointer arg2 = (PLPointer) 0 ;
24135  int res2 ;
24136  octave_value_list _out;
24137  octave_value_list *_outp=&_out;
24138  octave_value _outv;
24139 
24140  try {
24141  if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
24142  SWIG_fail;
24143  }
24144  {
24145  octave_value obj = args(0);
24146 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24147  if ( !obj.isempty() )
24148 #else
24149  if ( !obj.is_empty() )
24150 #endif
24151  {
24152  if ( obj.is_function_handle() || obj.is_inline_function() )
24153  {
24154  fcnLabelFunc = obj.function_value();
24155  }
24156  else if ( obj.is_string() )
24157  {
24158  nameLabelFunc = obj.string_value();
24159  fcnLabelFunc = NULL;
24160  }
24161  arg1 = labelfunc_octave;
24162  }
24163  else
24164  {
24165  arg1 = NULL;
24166  }
24167  }
24168  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24169  if (!SWIG_IsOK(res2)) {
24170  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
24171  }
24172  plslabelfunc(arg1,arg2);
24173  _outv = octave_value();
24174  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24175  return _out;
24176  fail:
24177  return octave_value_list();
24178  }
24179  catch(...) {
24180  throw;
24181  }
24182 }
24183 
24184 
24186  PLFLT arg1 ;
24187  PLFLT arg2 ;
24188  double val1 ;
24189  int ecode1 = 0 ;
24190  double val2 ;
24191  int ecode2 = 0 ;
24192  octave_value_list _out;
24193  octave_value_list *_outp=&_out;
24194  octave_value _outv;
24195 
24196  try {
24197  if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
24198  SWIG_fail;
24199  }
24200  ecode1 = SWIG_AsVal_double(args(0), &val1);
24201  if (!SWIG_IsOK(ecode1)) {
24202  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
24203  }
24204  arg1 = static_cast< PLFLT >(val1);
24205  ecode2 = SWIG_AsVal_double(args(1), &val2);
24206  if (!SWIG_IsOK(ecode2)) {
24207  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
24208  }
24209  arg2 = static_cast< PLFLT >(val2);
24210  plsmaj(arg1,arg2);
24211  _outv = octave_value();
24212  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24213  return _out;
24214  fail:
24215  return octave_value_list();
24216  }
24217  catch(...) {
24218  throw;
24219  }
24220 }
24221 
24222 
24224  PLFLT arg1 ;
24225  PLFLT arg2 ;
24226  double val1 ;
24227  int ecode1 = 0 ;
24228  double val2 ;
24229  int ecode2 = 0 ;
24230  octave_value_list _out;
24231  octave_value_list *_outp=&_out;
24232  octave_value _outv;
24233 
24234  try {
24235  if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
24236  SWIG_fail;
24237  }
24238  ecode1 = SWIG_AsVal_double(args(0), &val1);
24239  if (!SWIG_IsOK(ecode1)) {
24240  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
24241  }
24242  arg1 = static_cast< PLFLT >(val1);
24243  ecode2 = SWIG_AsVal_double(args(1), &val2);
24244  if (!SWIG_IsOK(ecode2)) {
24245  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
24246  }
24247  arg2 = static_cast< PLFLT >(val2);
24248  plsmin(arg1,arg2);
24249  _outv = octave_value();
24250  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24251  return _out;
24252  fail:
24253  return octave_value_list();
24254  }
24255  catch(...) {
24256  throw;
24257  }
24258 }
24259 
24260 
24262  PLINT arg1 ;
24263  int val1 ;
24264  int ecode1 = 0 ;
24265  octave_value_list _out;
24266  octave_value_list *_outp=&_out;
24267  octave_value _outv;
24268 
24269  try {
24270  if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
24271  SWIG_fail;
24272  }
24273  ecode1 = SWIG_AsVal_int(args(0), &val1);
24274  if (!SWIG_IsOK(ecode1)) {
24275  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
24276  }
24277  arg1 = static_cast< PLINT >(val1);
24278  plsori(arg1);
24279  _outv = octave_value();
24280  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24281  return _out;
24282  fail:
24283  return octave_value_list();
24284  }
24285  catch(...) {
24286  throw;
24287  }
24288 }
24289 
24290 
24292  PLFLT arg1 ;
24293  PLFLT arg2 ;
24294  PLINT arg3 ;
24295  PLINT arg4 ;
24296  PLINT arg5 ;
24297  PLINT arg6 ;
24298  double val1 ;
24299  int ecode1 = 0 ;
24300  double val2 ;
24301  int ecode2 = 0 ;
24302  int val3 ;
24303  int ecode3 = 0 ;
24304  int val4 ;
24305  int ecode4 = 0 ;
24306  int val5 ;
24307  int ecode5 = 0 ;
24308  int val6 ;
24309  int ecode6 = 0 ;
24310  octave_value_list _out;
24311  octave_value_list *_outp=&_out;
24312  octave_value _outv;
24313 
24314  try {
24315  if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
24316  SWIG_fail;
24317  }
24318  ecode1 = SWIG_AsVal_double(args(0), &val1);
24319  if (!SWIG_IsOK(ecode1)) {
24320  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
24321  }
24322  arg1 = static_cast< PLFLT >(val1);
24323  ecode2 = SWIG_AsVal_double(args(1), &val2);
24324  if (!SWIG_IsOK(ecode2)) {
24325  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
24326  }
24327  arg2 = static_cast< PLFLT >(val2);
24328  ecode3 = SWIG_AsVal_int(args(2), &val3);
24329  if (!SWIG_IsOK(ecode3)) {
24330  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
24331  }
24332  arg3 = static_cast< PLINT >(val3);
24333  ecode4 = SWIG_AsVal_int(args(3), &val4);
24334  if (!SWIG_IsOK(ecode4)) {
24335  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
24336  }
24337  arg4 = static_cast< PLINT >(val4);
24338  ecode5 = SWIG_AsVal_int(args(4), &val5);
24339  if (!SWIG_IsOK(ecode5)) {
24340  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
24341  }
24342  arg5 = static_cast< PLINT >(val5);
24343  ecode6 = SWIG_AsVal_int(args(5), &val6);
24344  if (!SWIG_IsOK(ecode6)) {
24345  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
24346  }
24347  arg6 = static_cast< PLINT >(val6);
24348  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
24349  _outv = octave_value();
24350  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24351  return _out;
24352  fail:
24353  return octave_value_list();
24354  }
24355  catch(...) {
24356  throw;
24357  }
24358 }
24359 
24360 
24362  char *arg1 = (char *) 0 ;
24363  int res1 ;
24364  char *buf1 = 0 ;
24365  int alloc1 = 0 ;
24366  octave_value_list _out;
24367  octave_value_list *_outp=&_out;
24368  octave_value _outv;
24369 
24370  try {
24371  if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
24372  SWIG_fail;
24373  }
24374  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24375  if (!SWIG_IsOK(res1)) {
24376  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
24377  }
24378  arg1 = reinterpret_cast< char * >(buf1);
24379  plspal0((char const *)arg1);
24380  _outv = octave_value();
24381  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24382  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24383  return _out;
24384  fail:
24385  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24386  return octave_value_list();
24387  }
24388  catch(...) {
24389  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24390  throw;
24391  }
24392 }
24393 
24394 
24396  char *arg1 = (char *) 0 ;
24397  PLBOOL arg2 ;
24398  int res1 ;
24399  char *buf1 = 0 ;
24400  int alloc1 = 0 ;
24401  int val2 ;
24402  int ecode2 = 0 ;
24403  octave_value_list _out;
24404  octave_value_list *_outp=&_out;
24405  octave_value _outv;
24406 
24407  try {
24408  if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
24409  SWIG_fail;
24410  }
24411  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24412  if (!SWIG_IsOK(res1)) {
24413  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
24414  }
24415  arg1 = reinterpret_cast< char * >(buf1);
24416  ecode2 = SWIG_AsVal_int(args(1), &val2);
24417  if (!SWIG_IsOK(ecode2)) {
24418  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
24419  }
24420  arg2 = static_cast< PLBOOL >(val2);
24421  plspal1((char const *)arg1,arg2);
24422  _outv = octave_value();
24423  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24424  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24425  return _out;
24426  fail:
24427  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24428  return octave_value_list();
24429  }
24430  catch(...) {
24431  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24432  throw;
24433  }
24434 }
24435 
24436 
24438  PLBOOL arg1 ;
24439  int val1 ;
24440  int ecode1 = 0 ;
24441  octave_value_list _out;
24442  octave_value_list *_outp=&_out;
24443  octave_value _outv;
24444 
24445  try {
24446  if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
24447  SWIG_fail;
24448  }
24449  ecode1 = SWIG_AsVal_int(args(0), &val1);
24450  if (!SWIG_IsOK(ecode1)) {
24451  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
24452  }
24453  arg1 = static_cast< PLBOOL >(val1);
24454  plspause(arg1);
24455  _outv = octave_value();
24456  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24457  return _out;
24458  fail:
24459  return octave_value_list();
24460  }
24461  catch(...) {
24462  throw;
24463  }
24464 }
24465 
24466 
24468  PLINT arg1 ;
24469  int val1 ;
24470  int ecode1 = 0 ;
24471  octave_value_list _out;
24472  octave_value_list *_outp=&_out;
24473  octave_value _outv;
24474 
24475  try {
24476  if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
24477  SWIG_fail;
24478  }
24479  ecode1 = SWIG_AsVal_int(args(0), &val1);
24480  if (!SWIG_IsOK(ecode1)) {
24481  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
24482  }
24483  arg1 = static_cast< PLINT >(val1);
24484  plsstrm(arg1);
24485  _outv = octave_value();
24486  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24487  return _out;
24488  fail:
24489  return octave_value_list();
24490  }
24491  catch(...) {
24492  throw;
24493  }
24494 }
24495 
24496 
24498  PLINT arg1 ;
24499  PLINT arg2 ;
24500  int val1 ;
24501  int ecode1 = 0 ;
24502  int val2 ;
24503  int ecode2 = 0 ;
24504  octave_value_list _out;
24505  octave_value_list *_outp=&_out;
24506  octave_value _outv;
24507 
24508  try {
24509  if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
24510  SWIG_fail;
24511  }
24512  ecode1 = SWIG_AsVal_int(args(0), &val1);
24513  if (!SWIG_IsOK(ecode1)) {
24514  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
24515  }
24516  arg1 = static_cast< PLINT >(val1);
24517  ecode2 = SWIG_AsVal_int(args(1), &val2);
24518  if (!SWIG_IsOK(ecode2)) {
24519  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
24520  }
24521  arg2 = static_cast< PLINT >(val2);
24522  plssub(arg1,arg2);
24523  _outv = octave_value();
24524  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24525  return _out;
24526  fail:
24527  return octave_value_list();
24528  }
24529  catch(...) {
24530  throw;
24531  }
24532 }
24533 
24534 
24536  PLFLT arg1 ;
24537  PLFLT arg2 ;
24538  double val1 ;
24539  int ecode1 = 0 ;
24540  double val2 ;
24541  int ecode2 = 0 ;
24542  octave_value_list _out;
24543  octave_value_list *_outp=&_out;
24544  octave_value _outv;
24545 
24546  try {
24547  if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
24548  SWIG_fail;
24549  }
24550  ecode1 = SWIG_AsVal_double(args(0), &val1);
24551  if (!SWIG_IsOK(ecode1)) {
24552  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
24553  }
24554  arg1 = static_cast< PLFLT >(val1);
24555  ecode2 = SWIG_AsVal_double(args(1), &val2);
24556  if (!SWIG_IsOK(ecode2)) {
24557  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
24558  }
24559  arg2 = static_cast< PLFLT >(val2);
24560  plssym(arg1,arg2);
24561  _outv = octave_value();
24562  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24563  return _out;
24564  fail:
24565  return octave_value_list();
24566  }
24567  catch(...) {
24568  throw;
24569  }
24570 }
24571 
24572 
24574  PLINT arg1 ;
24575  PLINT arg2 ;
24576  int val1 ;
24577  int ecode1 = 0 ;
24578  int val2 ;
24579  int ecode2 = 0 ;
24580  octave_value_list _out;
24581  octave_value_list *_outp=&_out;
24582  octave_value _outv;
24583 
24584  try {
24585  if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
24586  SWIG_fail;
24587  }
24588  ecode1 = SWIG_AsVal_int(args(0), &val1);
24589  if (!SWIG_IsOK(ecode1)) {
24590  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
24591  }
24592  arg1 = static_cast< PLINT >(val1);
24593  ecode2 = SWIG_AsVal_int(args(1), &val2);
24594  if (!SWIG_IsOK(ecode2)) {
24595  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
24596  }
24597  arg2 = static_cast< PLINT >(val2);
24598  plstar(arg1,arg2);
24599  _outv = octave_value();
24600  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24601  return _out;
24602  fail:
24603  return octave_value_list();
24604  }
24605  catch(...) {
24606  throw;
24607  }
24608 }
24609 
24610 
24612  char *arg1 = (char *) 0 ;
24613  PLINT arg2 ;
24614  PLINT arg3 ;
24615  int res1 ;
24616  char *buf1 = 0 ;
24617  int alloc1 = 0 ;
24618  int val2 ;
24619  int ecode2 = 0 ;
24620  int val3 ;
24621  int ecode3 = 0 ;
24622  octave_value_list _out;
24623  octave_value_list *_outp=&_out;
24624  octave_value _outv;
24625 
24626  try {
24627  if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
24628  SWIG_fail;
24629  }
24630  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24631  if (!SWIG_IsOK(res1)) {
24632  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
24633  }
24634  arg1 = reinterpret_cast< char * >(buf1);
24635  ecode2 = SWIG_AsVal_int(args(1), &val2);
24636  if (!SWIG_IsOK(ecode2)) {
24637  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
24638  }
24639  arg2 = static_cast< PLINT >(val2);
24640  ecode3 = SWIG_AsVal_int(args(2), &val3);
24641  if (!SWIG_IsOK(ecode3)) {
24642  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
24643  }
24644  arg3 = static_cast< PLINT >(val3);
24645  plstart((char const *)arg1,arg2,arg3);
24646  _outv = octave_value();
24647  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24648  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24649  return _out;
24650  fail:
24651  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24652  return octave_value_list();
24653  }
24654  catch(...) {
24655  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24656  throw;
24657  }
24658 }
24659 
24660 
24662  ct_func arg1 = (ct_func) 0 ;
24663  PLPointer arg2 = (PLPointer) 0 ;
24664  int res2 ;
24665  octave_value_list _out;
24666  octave_value_list *_outp=&_out;
24667  octave_value _outv;
24668 
24669  try {
24670  if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
24671  SWIG_fail;
24672  }
24673  {
24674  octave_value obj = args(0);
24675 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24676  if ( !obj.isempty() )
24677 #else
24678  if ( !obj.is_empty() )
24679 #endif
24680  {
24681  if ( obj.is_function_handle() || obj.is_inline_function() )
24682  {
24683  fcnCoordTrans = obj.function_value();
24684  }
24685  else if ( obj.is_string() )
24686  {
24687  nameCoordTrans = obj.string_value();
24688  fcnCoordTrans = NULL;
24689  }
24690  arg1 = ct_octave;
24691  }
24692  else
24693  {
24694  arg1 = NULL;
24695  }
24696  }
24697  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
24698  if (!SWIG_IsOK(res2)) {
24699  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
24700  }
24701  plstransform(arg1,arg2);
24702  _outv = octave_value();
24703  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24704  return _out;
24705  fail:
24706  return octave_value_list();
24707  }
24708  catch(...) {
24709  throw;
24710  }
24711 }
24712 
24713 
24715  PLINT arg1 ;
24716  PLFLT *arg2 = (PLFLT *) 0 ;
24717  PLFLT *arg3 = (PLFLT *) 0 ;
24718  char *arg4 = (char *) 0 ;
24719  Matrix temp1 ;
24720  Matrix temp3 ;
24721  int res4 ;
24722  char *buf4 = 0 ;
24723  int alloc4 = 0 ;
24724  octave_value_list _out;
24725  octave_value_list *_outp=&_out;
24726  octave_value _outv;
24727 
24728  try {
24729  if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
24730  SWIG_fail;
24731  }
24732  {
24733  if ( _n_dims( args(0) ) > 1 )
24734  {
24735  error( "argument must be a scalar or vector" ); SWIG_fail;
24736  }
24737  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24738  temp1 = args(0).matrix_value();
24739  arg2 = &temp1( 0, 0 );
24740  }
24741  {
24742  if ( _n_dims( args(1) ) > 1 )
24743  {
24744  error( "argument must be a scalar or vector" ); SWIG_fail;
24745  }
24746  if ( _dim( args(1), 0 ) != Alen )
24747  {
24748  error( "argument vectors must be same length" ); SWIG_fail;
24749  }
24750  temp3 = args(1).matrix_value();
24751  arg3 = &temp3( 0, 0 );
24752  }
24753  res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
24754  if (!SWIG_IsOK(res4)) {
24755  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
24756  }
24757  arg4 = reinterpret_cast< char * >(buf4);
24758  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
24759  _outv = octave_value();
24760  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24761  {
24762 
24763  }
24764  {
24765 
24766  }
24767  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24768  return _out;
24769  fail:
24770  {
24771 
24772  }
24773  {
24774 
24775  }
24776  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24777  return octave_value_list();
24778  }
24779  catch(...) {
24780  {
24781 
24782  }
24783  {
24784 
24785  }
24786  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
24787  throw;
24788  }
24789 }
24790 
24791 
24793  PLINT arg1 ;
24794  PLFLT *arg2 = (PLFLT *) 0 ;
24795  PLFLT *arg3 = (PLFLT *) 0 ;
24796  PLFLT *arg4 = (PLFLT *) 0 ;
24797  char *arg5 = (char *) 0 ;
24798  Matrix temp1 ;
24799  Matrix temp3 ;
24800  Matrix temp4 ;
24801  int res5 ;
24802  char *buf5 = 0 ;
24803  int alloc5 = 0 ;
24804  octave_value_list _out;
24805  octave_value_list *_outp=&_out;
24806  octave_value _outv;
24807 
24808  try {
24809  if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
24810  SWIG_fail;
24811  }
24812  {
24813  if ( _n_dims( args(0) ) > 1 )
24814  {
24815  error( "argument must be a scalar or vector" ); SWIG_fail;
24816  }
24817  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24818  temp1 = args(0).matrix_value();
24819  arg2 = &temp1( 0, 0 );
24820  }
24821  {
24822  if ( _n_dims( args(1) ) > 1 )
24823  {
24824  error( "argument must be a scalar or vector" ); SWIG_fail;
24825  }
24826  if ( _dim( args(1), 0 ) != Alen )
24827  {
24828  error( "argument vectors must be same length" ); SWIG_fail;
24829  }
24830  temp3 = args(1).matrix_value();
24831  arg3 = &temp3( 0, 0 );
24832  }
24833  {
24834  if ( _n_dims( args(2) ) > 1 )
24835  {
24836  error( "argument must be a scalar or vector" ); SWIG_fail;
24837  }
24838  if ( _dim( args(2), 0 ) != Alen )
24839  {
24840  error( "argument vectors must be same length" ); SWIG_fail;
24841  }
24842  temp4 = args(2).matrix_value();
24843  arg4 = &temp4( 0, 0 );
24844  }
24845  res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
24846  if (!SWIG_IsOK(res5)) {
24847  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
24848  }
24849  arg5 = reinterpret_cast< char * >(buf5);
24850  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
24851  _outv = octave_value();
24852  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24853  {
24854 
24855  }
24856  {
24857 
24858  }
24859  {
24860 
24861  }
24862  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24863  return _out;
24864  fail:
24865  {
24866 
24867  }
24868  {
24869 
24870  }
24871  {
24872 
24873  }
24874  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24875  return octave_value_list();
24876  }
24877  catch(...) {
24878  {
24879 
24880  }
24881  {
24882 
24883  }
24884  {
24885 
24886  }
24887  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
24888  throw;
24889  }
24890 }
24891 
24892 
24894  PLINT arg1 ;
24895  PLINT arg2 ;
24896  PLFLT arg3 ;
24897  PLFLT arg4 ;
24898  int val1 ;
24899  int ecode1 = 0 ;
24900  int val2 ;
24901  int ecode2 = 0 ;
24902  double val3 ;
24903  int ecode3 = 0 ;
24904  double val4 ;
24905  int ecode4 = 0 ;
24906  octave_value_list _out;
24907  octave_value_list *_outp=&_out;
24908  octave_value _outv;
24909 
24910  try {
24911  if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
24912  SWIG_fail;
24913  }
24914  ecode1 = SWIG_AsVal_int(args(0), &val1);
24915  if (!SWIG_IsOK(ecode1)) {
24916  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
24917  }
24918  arg1 = static_cast< PLINT >(val1);
24919  ecode2 = SWIG_AsVal_int(args(1), &val2);
24920  if (!SWIG_IsOK(ecode2)) {
24921  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
24922  }
24923  arg2 = static_cast< PLINT >(val2);
24924  ecode3 = SWIG_AsVal_double(args(2), &val3);
24925  if (!SWIG_IsOK(ecode3)) {
24926  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
24927  }
24928  arg3 = static_cast< PLFLT >(val3);
24929  ecode4 = SWIG_AsVal_double(args(3), &val4);
24930  if (!SWIG_IsOK(ecode4)) {
24931  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
24932  }
24933  arg4 = static_cast< PLFLT >(val4);
24934  plstripa(arg1,arg2,arg3,arg4);
24935  _outv = octave_value();
24936  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24937  return _out;
24938  fail:
24939  return octave_value_list();
24940  }
24941  catch(...) {
24942  throw;
24943  }
24944 }
24945 
24946 
24948  PLINT arg1 ;
24949  int val1 ;
24950  int ecode1 = 0 ;
24951  octave_value_list _out;
24952  octave_value_list *_outp=&_out;
24953  octave_value _outv;
24954 
24955  try {
24956  if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
24957  SWIG_fail;
24958  }
24959  ecode1 = SWIG_AsVal_int(args(0), &val1);
24960  if (!SWIG_IsOK(ecode1)) {
24961  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
24962  }
24963  arg1 = static_cast< PLINT >(val1);
24964  plstripd(arg1);
24965  _outv = octave_value();
24966  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24967  return _out;
24968  fail:
24969  return octave_value_list();
24970  }
24971  catch(...) {
24972  throw;
24973  }
24974 }
24975 
24976 
24978  PLINT arg1 ;
24979  PLINT *arg2 = (PLINT *) 0 ;
24980  PLINT *arg3 = (PLINT *) 0 ;
24981  Matrix temp1 ;
24982  Matrix temp3 ;
24983  octave_value_list _out;
24984  octave_value_list *_outp=&_out;
24985  octave_value _outv;
24986 
24987  try {
24988  if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
24989  SWIG_fail;
24990  }
24991  {
24992  if ( _n_dims( args(0) ) > 1 )
24993  {
24994  error( "argument must be a scalar or vector" ); SWIG_fail;
24995  }
24996  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
24997  arg2 = new PLINT[Alen];
24998  temp1 = args(0).matrix_value();
24999  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
25000  }
25001  {
25002  if ( _n_dims( args(1) ) > 1 )
25003  {
25004  error( "argument must be a scalar or vector" ); SWIG_fail;
25005  }
25006  if ( _dim( args(1), 0 ) != Alen )
25007  {
25008  error( "argument vectors must be same length" ); SWIG_fail;
25009  }
25010  temp3 = args(1).matrix_value();
25011  arg3 = new PLINT[Alen];
25012  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
25013  }
25014  plstyl(arg1,(int const *)arg2,(int const *)arg3);
25015  _outv = octave_value();
25016  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25017  {
25018  delete [] arg2;
25019  }
25020  {
25021  delete [] arg3;
25022  }
25023  return _out;
25024  fail:
25025  {
25026  delete [] arg2;
25027  }
25028  {
25029  delete [] arg3;
25030  }
25031  return octave_value_list();
25032  }
25033  catch(...) {
25034  {
25035  delete [] arg2;
25036  }
25037  {
25038  delete [] arg3;
25039  }
25040  throw;
25041  }
25042 }
25043 
25044 
25046  PLFLT *arg1 = (PLFLT *) 0 ;
25047  PLFLT *arg2 = (PLFLT *) 0 ;
25048  PLINT arg3 ;
25049  PLBOOL arg4 ;
25050  Matrix temp1 ;
25051  Matrix temp2 ;
25052  int val4 ;
25053  int ecode4 = 0 ;
25054  octave_value_list _out;
25055  octave_value_list *_outp=&_out;
25056  octave_value _outv;
25057 
25058  try {
25059  if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
25060  SWIG_fail;
25061  }
25062  {
25063  if ( _n_dims( args(0) ) > 1 )
25064  {
25065  error( "argument must be a scalar or vector" ); SWIG_fail;
25066  }
25067 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25068  if ( !args(0).isempty() )
25069 #else
25070  if ( !args(0).is_empty() )
25071 #endif
25072  {
25073  Alen = (PLINT) ( _dim( args(0), 0 ) );
25074  temp1 = args(0).matrix_value();
25075  arg1 = &temp1( 0, 0 );
25076  }
25077  else
25078  {
25079  arg1 = NULL;
25080  Alen = 0;
25081  }
25082  }
25083  {
25084  if ( _n_dims( args(1) ) > 1 )
25085  {
25086  error( "argument must be a scalar or vector" ); SWIG_fail;
25087  }
25088 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25089  if ( !args(1).isempty() )
25090 #else
25091  if ( !args(1).is_empty() )
25092 #endif
25093  {
25094  if ( _dim( args(1), 0 ) != Alen )
25095  {
25096  error( "argument vectors must be same length" ); SWIG_fail;
25097  }
25098  temp2 = args(1).matrix_value();
25099  arg2 = &temp2( 0, 0 );
25100  arg3 = (PLINT) ( _dim( args(1), 0 ) );
25101  }
25102  else
25103  {
25104  arg2 = NULL;
25105  arg3 = 0;
25106  }
25107  }
25108  ecode4 = SWIG_AsVal_int(args(2), &val4);
25109  if (!SWIG_IsOK(ecode4)) {
25110  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
25111  }
25112  arg4 = static_cast< PLBOOL >(val4);
25113  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
25114  _outv = octave_value();
25115  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25116  {
25117 
25118  }
25119  {
25120 
25121  }
25122  return _out;
25123  fail:
25124  {
25125 
25126  }
25127  {
25128 
25129  }
25130  return octave_value_list();
25131  }
25132  catch(...) {
25133  {
25134 
25135  }
25136  {
25137 
25138  }
25139  throw;
25140  }
25141 }
25142 
25143 
25145  PLFLT arg1 ;
25146  PLFLT arg2 ;
25147  PLFLT arg3 ;
25148  PLFLT arg4 ;
25149  double val1 ;
25150  int ecode1 = 0 ;
25151  double val2 ;
25152  int ecode2 = 0 ;
25153  double val3 ;
25154  int ecode3 = 0 ;
25155  double val4 ;
25156  int ecode4 = 0 ;
25157  octave_value_list _out;
25158  octave_value_list *_outp=&_out;
25159  octave_value _outv;
25160 
25161  try {
25162  if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
25163  SWIG_fail;
25164  }
25165  ecode1 = SWIG_AsVal_double(args(0), &val1);
25166  if (!SWIG_IsOK(ecode1)) {
25167  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
25168  }
25169  arg1 = static_cast< PLFLT >(val1);
25170  ecode2 = SWIG_AsVal_double(args(1), &val2);
25171  if (!SWIG_IsOK(ecode2)) {
25172  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
25173  }
25174  arg2 = static_cast< PLFLT >(val2);
25175  ecode3 = SWIG_AsVal_double(args(2), &val3);
25176  if (!SWIG_IsOK(ecode3)) {
25177  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
25178  }
25179  arg3 = static_cast< PLFLT >(val3);
25180  ecode4 = SWIG_AsVal_double(args(3), &val4);
25181  if (!SWIG_IsOK(ecode4)) {
25182  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
25183  }
25184  arg4 = static_cast< PLFLT >(val4);
25185  plsvpa(arg1,arg2,arg3,arg4);
25186  _outv = octave_value();
25187  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25188  return _out;
25189  fail:
25190  return octave_value_list();
25191  }
25192  catch(...) {
25193  throw;
25194  }
25195 }
25196 
25197 
25199  PLINT arg1 ;
25200  PLINT arg2 ;
25201  int val1 ;
25202  int ecode1 = 0 ;
25203  int val2 ;
25204  int ecode2 = 0 ;
25205  octave_value_list _out;
25206  octave_value_list *_outp=&_out;
25207  octave_value _outv;
25208 
25209  try {
25210  if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
25211  SWIG_fail;
25212  }
25213  ecode1 = SWIG_AsVal_int(args(0), &val1);
25214  if (!SWIG_IsOK(ecode1)) {
25215  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
25216  }
25217  arg1 = static_cast< PLINT >(val1);
25218  ecode2 = SWIG_AsVal_int(args(1), &val2);
25219  if (!SWIG_IsOK(ecode2)) {
25220  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
25221  }
25222  arg2 = static_cast< PLINT >(val2);
25223  plsxax(arg1,arg2);
25224  _outv = octave_value();
25225  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25226  return _out;
25227  fail:
25228  return octave_value_list();
25229  }
25230  catch(...) {
25231  throw;
25232  }
25233 }
25234 
25235 
25237  PLINT arg1 ;
25238  PLINT arg2 ;
25239  int val1 ;
25240  int ecode1 = 0 ;
25241  int val2 ;
25242  int ecode2 = 0 ;
25243  octave_value_list _out;
25244  octave_value_list *_outp=&_out;
25245  octave_value _outv;
25246 
25247  try {
25248  if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
25249  SWIG_fail;
25250  }
25251  ecode1 = SWIG_AsVal_int(args(0), &val1);
25252  if (!SWIG_IsOK(ecode1)) {
25253  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
25254  }
25255  arg1 = static_cast< PLINT >(val1);
25256  ecode2 = SWIG_AsVal_int(args(1), &val2);
25257  if (!SWIG_IsOK(ecode2)) {
25258  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
25259  }
25260  arg2 = static_cast< PLINT >(val2);
25261  plsyax(arg1,arg2);
25262  _outv = octave_value();
25263  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25264  return _out;
25265  fail:
25266  return octave_value_list();
25267  }
25268  catch(...) {
25269  throw;
25270  }
25271 }
25272 
25273 
25275  PLINT arg1 ;
25276  PLFLT *arg2 = (PLFLT *) 0 ;
25277  PLFLT *arg3 = (PLFLT *) 0 ;
25278  PLINT arg4 ;
25279  Matrix temp1 ;
25280  Matrix temp3 ;
25281  int val4 ;
25282  int ecode4 = 0 ;
25283  octave_value_list _out;
25284  octave_value_list *_outp=&_out;
25285  octave_value _outv;
25286 
25287  try {
25288  if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
25289  SWIG_fail;
25290  }
25291  {
25292  if ( _n_dims( args(0) ) > 1 )
25293  {
25294  error( "argument must be a scalar or vector" ); SWIG_fail;
25295  }
25296  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
25297  temp1 = args(0).matrix_value();
25298  arg2 = &temp1( 0, 0 );
25299  }
25300  {
25301  if ( _n_dims( args(1) ) > 1 )
25302  {
25303  error( "argument must be a scalar or vector" ); SWIG_fail;
25304  }
25305  if ( _dim( args(1), 0 ) != Alen )
25306  {
25307  error( "argument vectors must be same length" ); SWIG_fail;
25308  }
25309  temp3 = args(1).matrix_value();
25310  arg3 = &temp3( 0, 0 );
25311  }
25312  ecode4 = SWIG_AsVal_int(args(2), &val4);
25313  if (!SWIG_IsOK(ecode4)) {
25314  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
25315  }
25316  arg4 = static_cast< PLINT >(val4);
25317  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
25318  _outv = octave_value();
25319  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25320  {
25321 
25322  }
25323  {
25324 
25325  }
25326  return _out;
25327  fail:
25328  {
25329 
25330  }
25331  {
25332 
25333  }
25334  return octave_value_list();
25335  }
25336  catch(...) {
25337  {
25338 
25339  }
25340  {
25341 
25342  }
25343  throw;
25344  }
25345 }
25346 
25347 
25349  PLINT arg1 ;
25350  PLINT arg2 ;
25351  int val1 ;
25352  int ecode1 = 0 ;
25353  int val2 ;
25354  int ecode2 = 0 ;
25355  octave_value_list _out;
25356  octave_value_list *_outp=&_out;
25357  octave_value _outv;
25358 
25359  try {
25360  if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
25361  SWIG_fail;
25362  }
25363  ecode1 = SWIG_AsVal_int(args(0), &val1);
25364  if (!SWIG_IsOK(ecode1)) {
25365  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
25366  }
25367  arg1 = static_cast< PLINT >(val1);
25368  ecode2 = SWIG_AsVal_int(args(1), &val2);
25369  if (!SWIG_IsOK(ecode2)) {
25370  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
25371  }
25372  arg2 = static_cast< PLINT >(val2);
25373  plszax(arg1,arg2);
25374  _outv = octave_value();
25375  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25376  return _out;
25377  fail:
25378  return octave_value_list();
25379  }
25380  catch(...) {
25381  throw;
25382  }
25383 }
25384 
25385 
25387  octave_value_list _out;
25388  octave_value_list *_outp=&_out;
25389  octave_value _outv;
25390 
25391  try {
25392  if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
25393  SWIG_fail;
25394  }
25395  pltext();
25396  _outv = octave_value();
25397  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25398  return _out;
25399  fail:
25400  return octave_value_list();
25401  }
25402  catch(...) {
25403  throw;
25404  }
25405 }
25406 
25407 
25409  char *arg1 = (char *) 0 ;
25410  int res1 ;
25411  char *buf1 = 0 ;
25412  int alloc1 = 0 ;
25413  octave_value_list _out;
25414  octave_value_list *_outp=&_out;
25415  octave_value _outv;
25416 
25417  try {
25418  if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
25419  SWIG_fail;
25420  }
25421  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
25422  if (!SWIG_IsOK(res1)) {
25423  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
25424  }
25425  arg1 = reinterpret_cast< char * >(buf1);
25426  pltimefmt((char const *)arg1);
25427  _outv = octave_value();
25428  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25429  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25430  return _out;
25431  fail:
25432  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25433  return octave_value_list();
25434  }
25435  catch(...) {
25436  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
25437  throw;
25438  }
25439 }
25440 
25441 
25443  PLFLT arg1 ;
25444  double val1 ;
25445  int ecode1 = 0 ;
25446  octave_value_list _out;
25447  octave_value_list *_outp=&_out;
25448  octave_value _outv;
25449 
25450  try {
25451  if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
25452  SWIG_fail;
25453  }
25454  ecode1 = SWIG_AsVal_double(args(0), &val1);
25455  if (!SWIG_IsOK(ecode1)) {
25456  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
25457  }
25458  arg1 = static_cast< PLFLT >(val1);
25459  plvasp(arg1);
25460  _outv = octave_value();
25461  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25462  return _out;
25463  fail:
25464  return octave_value_list();
25465  }
25466  catch(...) {
25467  throw;
25468  }
25469 }
25470 
25471 
25473  PLFLT arg1 ;
25474  PLFLT arg2 ;
25475  PLFLT arg3 ;
25476  PLFLT arg4 ;
25477  PLFLT arg5 ;
25478  double val1 ;
25479  int ecode1 = 0 ;
25480  double val2 ;
25481  int ecode2 = 0 ;
25482  double val3 ;
25483  int ecode3 = 0 ;
25484  double val4 ;
25485  int ecode4 = 0 ;
25486  double val5 ;
25487  int ecode5 = 0 ;
25488  octave_value_list _out;
25489  octave_value_list *_outp=&_out;
25490  octave_value _outv;
25491 
25492  try {
25493  if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
25494  SWIG_fail;
25495  }
25496  ecode1 = SWIG_AsVal_double(args(0), &val1);
25497  if (!SWIG_IsOK(ecode1)) {
25498  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
25499  }
25500  arg1 = static_cast< PLFLT >(val1);
25501  ecode2 = SWIG_AsVal_double(args(1), &val2);
25502  if (!SWIG_IsOK(ecode2)) {
25503  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
25504  }
25505  arg2 = static_cast< PLFLT >(val2);
25506  ecode3 = SWIG_AsVal_double(args(2), &val3);
25507  if (!SWIG_IsOK(ecode3)) {
25508  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
25509  }
25510  arg3 = static_cast< PLFLT >(val3);
25511  ecode4 = SWIG_AsVal_double(args(3), &val4);
25512  if (!SWIG_IsOK(ecode4)) {
25513  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
25514  }
25515  arg4 = static_cast< PLFLT >(val4);
25516  ecode5 = SWIG_AsVal_double(args(4), &val5);
25517  if (!SWIG_IsOK(ecode5)) {
25518  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
25519  }
25520  arg5 = static_cast< PLFLT >(val5);
25521  plvpas(arg1,arg2,arg3,arg4,arg5);
25522  _outv = octave_value();
25523  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25524  return _out;
25525  fail:
25526  return octave_value_list();
25527  }
25528  catch(...) {
25529  throw;
25530  }
25531 }
25532 
25533 
25535  PLFLT arg1 ;
25536  PLFLT arg2 ;
25537  PLFLT arg3 ;
25538  PLFLT arg4 ;
25539  double val1 ;
25540  int ecode1 = 0 ;
25541  double val2 ;
25542  int ecode2 = 0 ;
25543  double val3 ;
25544  int ecode3 = 0 ;
25545  double val4 ;
25546  int ecode4 = 0 ;
25547  octave_value_list _out;
25548  octave_value_list *_outp=&_out;
25549  octave_value _outv;
25550 
25551  try {
25552  if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
25553  SWIG_fail;
25554  }
25555  ecode1 = SWIG_AsVal_double(args(0), &val1);
25556  if (!SWIG_IsOK(ecode1)) {
25557  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
25558  }
25559  arg1 = static_cast< PLFLT >(val1);
25560  ecode2 = SWIG_AsVal_double(args(1), &val2);
25561  if (!SWIG_IsOK(ecode2)) {
25562  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
25563  }
25564  arg2 = static_cast< PLFLT >(val2);
25565  ecode3 = SWIG_AsVal_double(args(2), &val3);
25566  if (!SWIG_IsOK(ecode3)) {
25567  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
25568  }
25569  arg3 = static_cast< PLFLT >(val3);
25570  ecode4 = SWIG_AsVal_double(args(3), &val4);
25571  if (!SWIG_IsOK(ecode4)) {
25572  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
25573  }
25574  arg4 = static_cast< PLFLT >(val4);
25575  plvpor(arg1,arg2,arg3,arg4);
25576  _outv = octave_value();
25577  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25578  return _out;
25579  fail:
25580  return octave_value_list();
25581  }
25582  catch(...) {
25583  throw;
25584  }
25585 }
25586 
25587 
25589  octave_value_list _out;
25590  octave_value_list *_outp=&_out;
25591  octave_value _outv;
25592 
25593  try {
25594  if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
25595  SWIG_fail;
25596  }
25597  plvsta();
25598  _outv = octave_value();
25599  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25600  return _out;
25601  fail:
25602  return octave_value_list();
25603  }
25604  catch(...) {
25605  throw;
25606  }
25607 }
25608 
25609 
25611  PLFLT arg1 ;
25612  PLFLT arg2 ;
25613  PLFLT arg3 ;
25614  PLFLT arg4 ;
25615  PLFLT arg5 ;
25616  PLFLT arg6 ;
25617  PLFLT arg7 ;
25618  PLFLT arg8 ;
25619  PLFLT arg9 ;
25620  PLFLT arg10 ;
25621  PLFLT arg11 ;
25622  double val1 ;
25623  int ecode1 = 0 ;
25624  double val2 ;
25625  int ecode2 = 0 ;
25626  double val3 ;
25627  int ecode3 = 0 ;
25628  double val4 ;
25629  int ecode4 = 0 ;
25630  double val5 ;
25631  int ecode5 = 0 ;
25632  double val6 ;
25633  int ecode6 = 0 ;
25634  double val7 ;
25635  int ecode7 = 0 ;
25636  double val8 ;
25637  int ecode8 = 0 ;
25638  double val9 ;
25639  int ecode9 = 0 ;
25640  double val10 ;
25641  int ecode10 = 0 ;
25642  double val11 ;
25643  int ecode11 = 0 ;
25644  octave_value_list _out;
25645  octave_value_list *_outp=&_out;
25646  octave_value _outv;
25647 
25648  try {
25649  if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
25650  SWIG_fail;
25651  }
25652  ecode1 = SWIG_AsVal_double(args(0), &val1);
25653  if (!SWIG_IsOK(ecode1)) {
25654  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
25655  }
25656  arg1 = static_cast< PLFLT >(val1);
25657  ecode2 = SWIG_AsVal_double(args(1), &val2);
25658  if (!SWIG_IsOK(ecode2)) {
25659  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
25660  }
25661  arg2 = static_cast< PLFLT >(val2);
25662  ecode3 = SWIG_AsVal_double(args(2), &val3);
25663  if (!SWIG_IsOK(ecode3)) {
25664  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
25665  }
25666  arg3 = static_cast< PLFLT >(val3);
25667  ecode4 = SWIG_AsVal_double(args(3), &val4);
25668  if (!SWIG_IsOK(ecode4)) {
25669  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
25670  }
25671  arg4 = static_cast< PLFLT >(val4);
25672  ecode5 = SWIG_AsVal_double(args(4), &val5);
25673  if (!SWIG_IsOK(ecode5)) {
25674  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
25675  }
25676  arg5 = static_cast< PLFLT >(val5);
25677  ecode6 = SWIG_AsVal_double(args(5), &val6);
25678  if (!SWIG_IsOK(ecode6)) {
25679  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
25680  }
25681  arg6 = static_cast< PLFLT >(val6);
25682  ecode7 = SWIG_AsVal_double(args(6), &val7);
25683  if (!SWIG_IsOK(ecode7)) {
25684  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
25685  }
25686  arg7 = static_cast< PLFLT >(val7);
25687  ecode8 = SWIG_AsVal_double(args(7), &val8);
25688  if (!SWIG_IsOK(ecode8)) {
25689  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
25690  }
25691  arg8 = static_cast< PLFLT >(val8);
25692  ecode9 = SWIG_AsVal_double(args(8), &val9);
25693  if (!SWIG_IsOK(ecode9)) {
25694  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
25695  }
25696  arg9 = static_cast< PLFLT >(val9);
25697  ecode10 = SWIG_AsVal_double(args(9), &val10);
25698  if (!SWIG_IsOK(ecode10)) {
25699  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
25700  }
25701  arg10 = static_cast< PLFLT >(val10);
25702  ecode11 = SWIG_AsVal_double(args(10), &val11);
25703  if (!SWIG_IsOK(ecode11)) {
25704  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
25705  }
25706  arg11 = static_cast< PLFLT >(val11);
25707  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25708  _outv = octave_value();
25709  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25710  return _out;
25711  fail:
25712  return octave_value_list();
25713  }
25714  catch(...) {
25715  throw;
25716  }
25717 }
25718 
25719 
25721  PLFLT arg1 ;
25722  double val1 ;
25723  int ecode1 = 0 ;
25724  octave_value_list _out;
25725  octave_value_list *_outp=&_out;
25726  octave_value _outv;
25727 
25728  try {
25729  if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
25730  SWIG_fail;
25731  }
25732  ecode1 = SWIG_AsVal_double(args(0), &val1);
25733  if (!SWIG_IsOK(ecode1)) {
25734  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
25735  }
25736  arg1 = static_cast< PLFLT >(val1);
25737  plwidth(arg1);
25738  _outv = octave_value();
25739  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25740  return _out;
25741  fail:
25742  return octave_value_list();
25743  }
25744  catch(...) {
25745  throw;
25746  }
25747 }
25748 
25749 
25751  PLFLT arg1 ;
25752  PLFLT arg2 ;
25753  PLFLT arg3 ;
25754  PLFLT arg4 ;
25755  double val1 ;
25756  int ecode1 = 0 ;
25757  double val2 ;
25758  int ecode2 = 0 ;
25759  double val3 ;
25760  int ecode3 = 0 ;
25761  double val4 ;
25762  int ecode4 = 0 ;
25763  octave_value_list _out;
25764  octave_value_list *_outp=&_out;
25765  octave_value _outv;
25766 
25767  try {
25768  if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
25769  SWIG_fail;
25770  }
25771  ecode1 = SWIG_AsVal_double(args(0), &val1);
25772  if (!SWIG_IsOK(ecode1)) {
25773  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
25774  }
25775  arg1 = static_cast< PLFLT >(val1);
25776  ecode2 = SWIG_AsVal_double(args(1), &val2);
25777  if (!SWIG_IsOK(ecode2)) {
25778  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
25779  }
25780  arg2 = static_cast< PLFLT >(val2);
25781  ecode3 = SWIG_AsVal_double(args(2), &val3);
25782  if (!SWIG_IsOK(ecode3)) {
25783  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
25784  }
25785  arg3 = static_cast< PLFLT >(val3);
25786  ecode4 = SWIG_AsVal_double(args(3), &val4);
25787  if (!SWIG_IsOK(ecode4)) {
25788  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
25789  }
25790  arg4 = static_cast< PLFLT >(val4);
25791  plwind(arg1,arg2,arg3,arg4);
25792  _outv = octave_value();
25793  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25794  return _out;
25795  fail:
25796  return octave_value_list();
25797  }
25798  catch(...) {
25799  throw;
25800  }
25801 }
25802 
25803 
25805  PLBOOL arg1 ;
25806  PLBOOL *arg2 = (PLBOOL *) 0 ;
25807  int val1 ;
25808  int ecode1 = 0 ;
25809  PLBOOL temp2 ;
25810  int res2 = SWIG_TMPOBJ ;
25811  octave_value_list _out;
25812  octave_value_list *_outp=&_out;
25813  octave_value _outv;
25814 
25815  try {
25816  arg2 = &temp2;
25817  if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
25818  SWIG_fail;
25819  }
25820  ecode1 = SWIG_AsVal_int(args(0), &val1);
25821  if (!SWIG_IsOK(ecode1)) {
25822  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
25823  }
25824  arg1 = static_cast< PLBOOL >(val1);
25825  plxormod(arg1,arg2);
25826  _outv = octave_value();
25827  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25828  if (SWIG_IsTmpObj(res2)) {
25829  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
25830  } else {
25831  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25832  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
25833  }
25834  return _out;
25835  fail:
25836  return octave_value_list();
25837  }
25838  catch(...) {
25839  throw;
25840  }
25841 }
25842 
25843 
25845  mapform_func arg1 = (mapform_func) 0 ;
25846  char *arg2 = (char *) 0 ;
25847  PLFLT arg3 ;
25848  PLFLT arg4 ;
25849  PLFLT arg5 ;
25850  PLFLT arg6 ;
25851  int res2 ;
25852  char *buf2 = 0 ;
25853  int alloc2 = 0 ;
25854  double val3 ;
25855  int ecode3 = 0 ;
25856  double val4 ;
25857  int ecode4 = 0 ;
25858  double val5 ;
25859  int ecode5 = 0 ;
25860  double val6 ;
25861  int ecode6 = 0 ;
25862  octave_value_list _out;
25863  octave_value_list *_outp=&_out;
25864  octave_value _outv;
25865 
25866  try {
25867  if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
25868  SWIG_fail;
25869  }
25870  {
25871  octave_value obj = args(0);
25872 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25873  if ( !obj.isempty() )
25874 #else
25875  if ( !obj.is_empty() )
25876 #endif
25877  {
25878  if ( obj.is_function_handle() || obj.is_inline_function() )
25879  {
25880  fcnMapForm = obj.function_value();
25881  }
25882  else if ( obj.is_string() )
25883  {
25884  nameMapForm = obj.string_value();
25885  fcnMapForm = NULL;
25886  }
25887  arg1 = mapform_octave;
25888  }
25889  else
25890  {
25891  arg1 = NULL;
25892  }
25893  }
25894  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
25895  if (!SWIG_IsOK(res2)) {
25896  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
25897  }
25898  arg2 = reinterpret_cast< char * >(buf2);
25899  ecode3 = SWIG_AsVal_double(args(2), &val3);
25900  if (!SWIG_IsOK(ecode3)) {
25901  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
25902  }
25903  arg3 = static_cast< PLFLT >(val3);
25904  ecode4 = SWIG_AsVal_double(args(3), &val4);
25905  if (!SWIG_IsOK(ecode4)) {
25906  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
25907  }
25908  arg4 = static_cast< PLFLT >(val4);
25909  ecode5 = SWIG_AsVal_double(args(4), &val5);
25910  if (!SWIG_IsOK(ecode5)) {
25911  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
25912  }
25913  arg5 = static_cast< PLFLT >(val5);
25914  ecode6 = SWIG_AsVal_double(args(5), &val6);
25915  if (!SWIG_IsOK(ecode6)) {
25916  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
25917  }
25918  arg6 = static_cast< PLFLT >(val6);
25919  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
25920  _outv = octave_value();
25921  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
25922  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25923  return _out;
25924  fail:
25925  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25926  return octave_value_list();
25927  }
25928  catch(...) {
25929  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
25930  throw;
25931  }
25932 }
25933 
25934 
25936  mapform_func arg1 = (mapform_func) 0 ;
25937  char *arg2 = (char *) 0 ;
25938  PLFLT arg3 ;
25939  PLFLT arg4 ;
25940  PLFLT arg5 ;
25941  PLFLT arg6 ;
25942  PLINT *arg7 = (PLINT *) 0 ;
25943  PLINT arg8 ;
25944  int res2 ;
25945  char *buf2 = 0 ;
25946  int alloc2 = 0 ;
25947  double val3 ;
25948  int ecode3 = 0 ;
25949  double val4 ;
25950  int ecode4 = 0 ;
25951  double val5 ;
25952  int ecode5 = 0 ;
25953  double val6 ;
25954  int ecode6 = 0 ;
25955  Matrix temp7 ;
25956  octave_value_list _out;
25957  octave_value_list *_outp=&_out;
25958  octave_value _outv;
25959 
25960  try {
25961  if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
25962  SWIG_fail;
25963  }
25964  {
25965  octave_value obj = args(0);
25966 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
25967  if ( !obj.isempty() )
25968 #else
25969  if ( !obj.is_empty() )
25970 #endif
25971  {
25972  if ( obj.is_function_handle() || obj.is_inline_function() )
25973  {
25974  fcnMapForm = obj.function_value();
25975  }
25976  else if ( obj.is_string() )
25977  {
25978  nameMapForm = obj.string_value();
25979  fcnMapForm = NULL;
25980  }
25981  arg1 = mapform_octave;
25982  }
25983  else
25984  {
25985  arg1 = NULL;
25986  }
25987  }
25988  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
25989  if (!SWIG_IsOK(res2)) {
25990  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
25991  }
25992  arg2 = reinterpret_cast< char * >(buf2);
25993  ecode3 = SWIG_AsVal_double(args(2), &val3);
25994  if (!SWIG_IsOK(ecode3)) {
25995  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
25996  }
25997  arg3 = static_cast< PLFLT >(val3);
25998  ecode4 = SWIG_AsVal_double(args(3), &val4);
25999  if (!SWIG_IsOK(ecode4)) {
26000  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
26001  }
26002  arg4 = static_cast< PLFLT >(val4);
26003  ecode5 = SWIG_AsVal_double(args(4), &val5);
26004  if (!SWIG_IsOK(ecode5)) {
26005  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
26006  }
26007  arg5 = static_cast< PLFLT >(val5);
26008  ecode6 = SWIG_AsVal_double(args(5), &val6);
26009  if (!SWIG_IsOK(ecode6)) {
26010  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
26011  }
26012  arg6 = static_cast< PLFLT >(val6);
26013  {
26014  if ( _n_dims( args(6) ) > 1 )
26015  {
26016  error( "argument must be a scalar or vector" ); SWIG_fail;
26017  }
26018 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26019  if ( !args(6).isempty() )
26020 #else
26021  if ( !args(6).is_empty() )
26022 #endif
26023  {
26024  arg8 = (PLINT) ( _dim( args(6), 0 ) );
26025  temp7 = args(6).matrix_value();
26026  arg7 = new PLINT[arg8];
26027  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26028  }
26029  else
26030  {
26031  arg7 = NULL;
26032  arg8 = 0;
26033  }
26034  }
26035  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26036  _outv = octave_value();
26037  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26038  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26039  {
26040  delete [] arg7;
26041  }
26042  return _out;
26043  fail:
26044  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26045  {
26046  delete [] arg7;
26047  }
26048  return octave_value_list();
26049  }
26050  catch(...) {
26051  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26052  {
26053  delete [] arg7;
26054  }
26055  throw;
26056  }
26057 }
26058 
26059 
26061  mapform_func arg1 = (mapform_func) 0 ;
26062  char *arg2 = (char *) 0 ;
26063  char *arg3 = (char *) 0 ;
26064  PLFLT arg4 ;
26065  PLFLT arg5 ;
26066  PLFLT arg6 ;
26067  PLFLT arg7 ;
26068  PLINT *arg8 = (PLINT *) 0 ;
26069  PLINT arg9 ;
26070  int res2 ;
26071  char *buf2 = 0 ;
26072  int alloc2 = 0 ;
26073  int res3 ;
26074  char *buf3 = 0 ;
26075  int alloc3 = 0 ;
26076  double val4 ;
26077  int ecode4 = 0 ;
26078  double val5 ;
26079  int ecode5 = 0 ;
26080  double val6 ;
26081  int ecode6 = 0 ;
26082  double val7 ;
26083  int ecode7 = 0 ;
26084  Matrix temp8 ;
26085  octave_value_list _out;
26086  octave_value_list *_outp=&_out;
26087  octave_value _outv;
26088 
26089  try {
26090  if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
26091  SWIG_fail;
26092  }
26093  {
26094  octave_value obj = args(0);
26095 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26096  if ( !obj.isempty() )
26097 #else
26098  if ( !obj.is_empty() )
26099 #endif
26100  {
26101  if ( obj.is_function_handle() || obj.is_inline_function() )
26102  {
26103  fcnMapForm = obj.function_value();
26104  }
26105  else if ( obj.is_string() )
26106  {
26107  nameMapForm = obj.string_value();
26108  fcnMapForm = NULL;
26109  }
26110  arg1 = mapform_octave;
26111  }
26112  else
26113  {
26114  arg1 = NULL;
26115  }
26116  }
26117  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26118  if (!SWIG_IsOK(res2)) {
26119  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
26120  }
26121  arg2 = reinterpret_cast< char * >(buf2);
26122  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
26123  if (!SWIG_IsOK(res3)) {
26124  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
26125  }
26126  arg3 = reinterpret_cast< char * >(buf3);
26127  ecode4 = SWIG_AsVal_double(args(3), &val4);
26128  if (!SWIG_IsOK(ecode4)) {
26129  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
26130  }
26131  arg4 = static_cast< PLFLT >(val4);
26132  ecode5 = SWIG_AsVal_double(args(4), &val5);
26133  if (!SWIG_IsOK(ecode5)) {
26134  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
26135  }
26136  arg5 = static_cast< PLFLT >(val5);
26137  ecode6 = SWIG_AsVal_double(args(5), &val6);
26138  if (!SWIG_IsOK(ecode6)) {
26139  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
26140  }
26141  arg6 = static_cast< PLFLT >(val6);
26142  ecode7 = SWIG_AsVal_double(args(6), &val7);
26143  if (!SWIG_IsOK(ecode7)) {
26144  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
26145  }
26146  arg7 = static_cast< PLFLT >(val7);
26147  {
26148  if ( _n_dims( args(7) ) > 1 )
26149  {
26150  error( "argument must be a scalar or vector" ); SWIG_fail;
26151  }
26152 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26153  if ( !args(7).isempty() )
26154 #else
26155  if ( !args(7).is_empty() )
26156 #endif
26157  {
26158  arg9 = (PLINT) ( _dim( args(7), 0 ) );
26159  temp8 = args(7).matrix_value();
26160  arg8 = new PLINT[arg9];
26161  _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
26162  }
26163  else
26164  {
26165  arg8 = NULL;
26166  arg9 = 0;
26167  }
26168  }
26169  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
26170  _outv = octave_value();
26171  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26172  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26173  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26174  {
26175  delete [] arg8;
26176  }
26177  return _out;
26178  fail:
26179  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26180  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26181  {
26182  delete [] arg8;
26183  }
26184  return octave_value_list();
26185  }
26186  catch(...) {
26187  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26188  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
26189  {
26190  delete [] arg8;
26191  }
26192  throw;
26193  }
26194 }
26195 
26196 
26198  mapform_func arg1 = (mapform_func) 0 ;
26199  char *arg2 = (char *) 0 ;
26200  PLFLT arg3 ;
26201  PLFLT arg4 ;
26202  PLFLT arg5 ;
26203  char *arg6 = (char *) 0 ;
26204  PLFLT arg7 ;
26205  PLFLT arg8 ;
26206  PLFLT arg9 ;
26207  PLFLT arg10 ;
26208  PLINT arg11 ;
26209  int res2 ;
26210  char *buf2 = 0 ;
26211  int alloc2 = 0 ;
26212  double val3 ;
26213  int ecode3 = 0 ;
26214  double val4 ;
26215  int ecode4 = 0 ;
26216  double val5 ;
26217  int ecode5 = 0 ;
26218  int res6 ;
26219  char *buf6 = 0 ;
26220  int alloc6 = 0 ;
26221  double val7 ;
26222  int ecode7 = 0 ;
26223  double val8 ;
26224  int ecode8 = 0 ;
26225  double val9 ;
26226  int ecode9 = 0 ;
26227  double val10 ;
26228  int ecode10 = 0 ;
26229  int val11 ;
26230  int ecode11 = 0 ;
26231  octave_value_list _out;
26232  octave_value_list *_outp=&_out;
26233  octave_value _outv;
26234 
26235  try {
26236  if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
26237  SWIG_fail;
26238  }
26239  {
26240  octave_value obj = args(0);
26241 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26242  if ( !obj.isempty() )
26243 #else
26244  if ( !obj.is_empty() )
26245 #endif
26246  {
26247  if ( obj.is_function_handle() || obj.is_inline_function() )
26248  {
26249  fcnMapForm = obj.function_value();
26250  }
26251  else if ( obj.is_string() )
26252  {
26253  nameMapForm = obj.string_value();
26254  fcnMapForm = NULL;
26255  }
26256  arg1 = mapform_octave;
26257  }
26258  else
26259  {
26260  arg1 = NULL;
26261  }
26262  }
26263  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26264  if (!SWIG_IsOK(res2)) {
26265  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
26266  }
26267  arg2 = reinterpret_cast< char * >(buf2);
26268  ecode3 = SWIG_AsVal_double(args(2), &val3);
26269  if (!SWIG_IsOK(ecode3)) {
26270  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
26271  }
26272  arg3 = static_cast< PLFLT >(val3);
26273  ecode4 = SWIG_AsVal_double(args(3), &val4);
26274  if (!SWIG_IsOK(ecode4)) {
26275  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
26276  }
26277  arg4 = static_cast< PLFLT >(val4);
26278  ecode5 = SWIG_AsVal_double(args(4), &val5);
26279  if (!SWIG_IsOK(ecode5)) {
26280  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
26281  }
26282  arg5 = static_cast< PLFLT >(val5);
26283  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
26284  if (!SWIG_IsOK(res6)) {
26285  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
26286  }
26287  arg6 = reinterpret_cast< char * >(buf6);
26288  ecode7 = SWIG_AsVal_double(args(6), &val7);
26289  if (!SWIG_IsOK(ecode7)) {
26290  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
26291  }
26292  arg7 = static_cast< PLFLT >(val7);
26293  ecode8 = SWIG_AsVal_double(args(7), &val8);
26294  if (!SWIG_IsOK(ecode8)) {
26295  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
26296  }
26297  arg8 = static_cast< PLFLT >(val8);
26298  ecode9 = SWIG_AsVal_double(args(8), &val9);
26299  if (!SWIG_IsOK(ecode9)) {
26300  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
26301  }
26302  arg9 = static_cast< PLFLT >(val9);
26303  ecode10 = SWIG_AsVal_double(args(9), &val10);
26304  if (!SWIG_IsOK(ecode10)) {
26305  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
26306  }
26307  arg10 = static_cast< PLFLT >(val10);
26308  ecode11 = SWIG_AsVal_int(args(10), &val11);
26309  if (!SWIG_IsOK(ecode11)) {
26310  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
26311  }
26312  arg11 = static_cast< PLINT >(val11);
26313  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
26314  _outv = octave_value();
26315  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26316  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26317  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26318  return _out;
26319  fail:
26320  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26321  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26322  return octave_value_list();
26323  }
26324  catch(...) {
26325  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26326  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
26327  throw;
26328  }
26329 }
26330 
26331 
26333  mapform_func arg1 = (mapform_func) 0 ;
26334  char *arg2 = (char *) 0 ;
26335  PLFLT arg3 ;
26336  PLFLT arg4 ;
26337  PLFLT arg5 ;
26338  PLFLT arg6 ;
26339  PLINT *arg7 = (PLINT *) 0 ;
26340  PLINT arg8 ;
26341  int res2 ;
26342  char *buf2 = 0 ;
26343  int alloc2 = 0 ;
26344  double val3 ;
26345  int ecode3 = 0 ;
26346  double val4 ;
26347  int ecode4 = 0 ;
26348  double val5 ;
26349  int ecode5 = 0 ;
26350  double val6 ;
26351  int ecode6 = 0 ;
26352  Matrix temp7 ;
26353  octave_value_list _out;
26354  octave_value_list *_outp=&_out;
26355  octave_value _outv;
26356 
26357  try {
26358  if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
26359  SWIG_fail;
26360  }
26361  {
26362  octave_value obj = args(0);
26363 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26364  if ( !obj.isempty() )
26365 #else
26366  if ( !obj.is_empty() )
26367 #endif
26368  {
26369  if ( obj.is_function_handle() || obj.is_inline_function() )
26370  {
26371  fcnMapForm = obj.function_value();
26372  }
26373  else if ( obj.is_string() )
26374  {
26375  nameMapForm = obj.string_value();
26376  fcnMapForm = NULL;
26377  }
26378  arg1 = mapform_octave;
26379  }
26380  else
26381  {
26382  arg1 = NULL;
26383  }
26384  }
26385  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26386  if (!SWIG_IsOK(res2)) {
26387  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
26388  }
26389  arg2 = reinterpret_cast< char * >(buf2);
26390  ecode3 = SWIG_AsVal_double(args(2), &val3);
26391  if (!SWIG_IsOK(ecode3)) {
26392  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
26393  }
26394  arg3 = static_cast< PLFLT >(val3);
26395  ecode4 = SWIG_AsVal_double(args(3), &val4);
26396  if (!SWIG_IsOK(ecode4)) {
26397  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
26398  }
26399  arg4 = static_cast< PLFLT >(val4);
26400  ecode5 = SWIG_AsVal_double(args(4), &val5);
26401  if (!SWIG_IsOK(ecode5)) {
26402  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
26403  }
26404  arg5 = static_cast< PLFLT >(val5);
26405  ecode6 = SWIG_AsVal_double(args(5), &val6);
26406  if (!SWIG_IsOK(ecode6)) {
26407  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
26408  }
26409  arg6 = static_cast< PLFLT >(val6);
26410  {
26411  if ( _n_dims( args(6) ) > 1 )
26412  {
26413  error( "argument must be a scalar or vector" ); SWIG_fail;
26414  }
26415 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26416  if ( !args(6).isempty() )
26417 #else
26418  if ( !args(6).is_empty() )
26419 #endif
26420  {
26421  arg8 = (PLINT) ( _dim( args(6), 0 ) );
26422  temp7 = args(6).matrix_value();
26423  arg7 = new PLINT[arg8];
26424  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
26425  }
26426  else
26427  {
26428  arg7 = NULL;
26429  arg8 = 0;
26430  }
26431  }
26432  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
26433  _outv = octave_value();
26434  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26435  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26436  {
26437  delete [] arg7;
26438  }
26439  return _out;
26440  fail:
26441  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26442  {
26443  delete [] arg7;
26444  }
26445  return octave_value_list();
26446  }
26447  catch(...) {
26448  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26449  {
26450  delete [] arg7;
26451  }
26452  throw;
26453  }
26454 }
26455 
26456 
26458  mapform_func arg1 = (mapform_func) 0 ;
26459  PLFLT arg2 ;
26460  PLFLT arg3 ;
26461  PLFLT arg4 ;
26462  PLFLT arg5 ;
26463  PLFLT arg6 ;
26464  PLFLT arg7 ;
26465  double val2 ;
26466  int ecode2 = 0 ;
26467  double val3 ;
26468  int ecode3 = 0 ;
26469  double val4 ;
26470  int ecode4 = 0 ;
26471  double val5 ;
26472  int ecode5 = 0 ;
26473  double val6 ;
26474  int ecode6 = 0 ;
26475  double val7 ;
26476  int ecode7 = 0 ;
26477  octave_value_list _out;
26478  octave_value_list *_outp=&_out;
26479  octave_value _outv;
26480 
26481  try {
26482  if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
26483  SWIG_fail;
26484  }
26485  {
26486  octave_value obj = args(0);
26487 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
26488  if ( !obj.isempty() )
26489 #else
26490  if ( !obj.is_empty() )
26491 #endif
26492  {
26493  if ( obj.is_function_handle() || obj.is_inline_function() )
26494  {
26495  fcnMapForm = obj.function_value();
26496  }
26497  else if ( obj.is_string() )
26498  {
26499  nameMapForm = obj.string_value();
26500  fcnMapForm = NULL;
26501  }
26502  arg1 = mapform_octave;
26503  }
26504  else
26505  {
26506  arg1 = NULL;
26507  }
26508  }
26509  ecode2 = SWIG_AsVal_double(args(1), &val2);
26510  if (!SWIG_IsOK(ecode2)) {
26511  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
26512  }
26513  arg2 = static_cast< PLFLT >(val2);
26514  ecode3 = SWIG_AsVal_double(args(2), &val3);
26515  if (!SWIG_IsOK(ecode3)) {
26516  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
26517  }
26518  arg3 = static_cast< PLFLT >(val3);
26519  ecode4 = SWIG_AsVal_double(args(3), &val4);
26520  if (!SWIG_IsOK(ecode4)) {
26521  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
26522  }
26523  arg4 = static_cast< PLFLT >(val4);
26524  ecode5 = SWIG_AsVal_double(args(4), &val5);
26525  if (!SWIG_IsOK(ecode5)) {
26526  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
26527  }
26528  arg5 = static_cast< PLFLT >(val5);
26529  ecode6 = SWIG_AsVal_double(args(5), &val6);
26530  if (!SWIG_IsOK(ecode6)) {
26531  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
26532  }
26533  arg6 = static_cast< PLFLT >(val6);
26534  ecode7 = SWIG_AsVal_double(args(6), &val7);
26535  if (!SWIG_IsOK(ecode7)) {
26536  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
26537  }
26538  arg7 = static_cast< PLFLT >(val7);
26539  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
26540  _outv = octave_value();
26541  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26542  return _out;
26543  fail:
26544  return octave_value_list();
26545  }
26546  catch(...) {
26547  throw;
26548  }
26549 }
26550 
26551 
26553  octave_value_list _out;
26554  octave_value_list *_outp=&_out;
26555  octave_value _outv;
26556 
26557  try {
26558  if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
26559  SWIG_fail;
26560  }
26561  plClearOpts();
26562  _outv = octave_value();
26563  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26564  return _out;
26565  fail:
26566  return octave_value_list();
26567  }
26568  catch(...) {
26569  throw;
26570  }
26571 }
26572 
26573 
26575  octave_value_list _out;
26576  octave_value_list *_outp=&_out;
26577  octave_value _outv;
26578 
26579  try {
26580  if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
26581  SWIG_fail;
26582  }
26583  plResetOpts();
26584  _outv = octave_value();
26585  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26586  return _out;
26587  fail:
26588  return octave_value_list();
26589  }
26590  catch(...) {
26591  throw;
26592  }
26593 }
26594 
26595 
26597  char *arg1 = (char *) 0 ;
26598  char *arg2 = (char *) 0 ;
26599  int res1 ;
26600  char *buf1 = 0 ;
26601  int alloc1 = 0 ;
26602  int res2 ;
26603  char *buf2 = 0 ;
26604  int alloc2 = 0 ;
26605  octave_value_list _out;
26606  octave_value_list *_outp=&_out;
26607  octave_value _outv;
26608 
26609  try {
26610  if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
26611  SWIG_fail;
26612  }
26613  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
26614  if (!SWIG_IsOK(res1)) {
26615  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
26616  }
26617  arg1 = reinterpret_cast< char * >(buf1);
26618  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
26619  if (!SWIG_IsOK(res2)) {
26620  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
26621  }
26622  arg2 = reinterpret_cast< char * >(buf2);
26623  plSetUsage((char const *)arg1,(char const *)arg2);
26624  _outv = octave_value();
26625  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26626  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26627  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26628  return _out;
26629  fail:
26630  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26631  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26632  return octave_value_list();
26633  }
26634  catch(...) {
26635  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
26636  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
26637  throw;
26638  }
26639 }
26640 
26641 
26643  octave_value_list _out;
26644  octave_value_list *_outp=&_out;
26645  octave_value _outv;
26646 
26647  try {
26648  if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
26649  SWIG_fail;
26650  }
26651  plOptUsage();
26652  _outv = octave_value();
26653  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
26654  return _out;
26655  fail:
26656  return octave_value_list();
26657  }
26658  catch(...) {
26659  throw;
26660  }
26661 }
26662 
26663 
26664 
26665 static const struct swig_octave_member swig_globals[] = {
26666 {"testppchar",_wrap_testppchar,0,0,2,0},
26667 {"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
26668 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
26669 {"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
26670 {"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
26671 {"plcont0",_wrap_plcont0,0,0,2,0},
26672 {"plcont1",_wrap_plcont1,0,0,2,0},
26673 {"plcont2",_wrap_plcont2,0,0,2,0},
26674 {"plcont2p",_wrap_plcont2p,0,0,2,0},
26675 {"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
26676 {"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
26677 {"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
26678 {"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
26679 {"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
26680 {"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
26681 {"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
26682 {"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
26683 {"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
26684 {"plshade1",_wrap_plshade1,0,0,2,0},
26685 {"plshade2",_wrap_plshade2,0,0,2,0},
26686 {"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
26687 {"plshadesx",_wrap_plshadesx,0,0,2,0},
26688 {"plshades1",_wrap_plshades1,0,0,2,0},
26689 {"plshades2",_wrap_plshades2,0,0,2,0},
26690 {"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
26691 {"plvect1",_wrap_plvect1,0,0,2,0},
26692 {"plvect2",_wrap_plvect2,0,0,2,0},
26693 {"pplimage",_wrap_pplimage,0,0,2,0},
26694 {"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
26695 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
26696 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
26697 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
26698 {"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
26699 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
26700 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
26701 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
26702 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
26703 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
26704 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
26705 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
26706 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
26707 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
26708 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
26709 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
26710 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
26711 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
26712 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
26713 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
26714 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
26715 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
26716 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
26717 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
26718 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
26719 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
26720 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
26721 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
26722 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
26723 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
26724 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
26726 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
26727 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
26728 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
26729 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
26730 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
26731 {"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
26732 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
26733 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
26734 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
26735 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
26736 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
26737 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
26738 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
26739 {"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
26740 {"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
26741 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
26742 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
26743 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
26744 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
26745 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
26746 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
26747 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
26748 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
26749 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
26750 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
26751 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
26752 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
26753 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
26754 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
26755 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
26756 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
26757 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
26758 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
26759 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
26760 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
26761 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
26762 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
26763 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
26764 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
26765 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
26766 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
26767 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
26768 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
26769 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
26770 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
26771 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
26772 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
26773 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
26774 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
26775 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
26776 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
26777 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
26778 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
26779 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
26780 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
26781 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
26782 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
26783 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
26784 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
26785 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
26786 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
26787 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
26788 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
26789 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
26790 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
26791 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
26792 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
26793 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
26794 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
26795 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
26796 {"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
26797 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
26798 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
26799 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
26800 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
26801 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
26802 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
26803 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
26804 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
26805 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
26806 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
26807 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
26808 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
26809 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
26810 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
26811 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
26812 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
26813 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
26814 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
26815 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
26816 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
26817 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
26818 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
26819 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
26820 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
26821 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
26822 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
26823 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
26824 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
26825 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
26826 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
26827 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
26828 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
26829 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
26830 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
26831 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
26832 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
26833 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
26834 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
26835 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
26836 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
26837 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
26838 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
26839 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
26840 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
26841 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
26842 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
26843 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
26844 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
26845 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
26846 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
26847 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
26848 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
26849 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
26850 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
26851 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
26852 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
26853 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
26854 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
26855 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
26856 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
26857 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
26858 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
26859 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
26860 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
26861 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
26862 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
26863 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
26864 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
26865 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
26866 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
26867 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
26868 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
26869 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
26870 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
26871 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
26872 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
26873 {"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
26874 {"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
26875 {"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
26876 {"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
26877 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
26878 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
26879 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
26880 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
26881 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
26882 {0,0,0,0,0,0}
26883 };
26884 
26885 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
26886 
26887 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
26888 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
26889 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
26890 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};
26891 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};
26892 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};
26893 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
26894 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
26895 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
26896 
26899  &_swigt__p_char,
26904  &_swigt__p_int,
26907 };
26908 
26909 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
26910 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
26911 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
26915 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
26916 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
26917 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
26918 
26926  _swigc__p_int,
26929 };
26930 
26931 
26932 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
26933 
26934 /* -----------------------------------------------------------------------------
26935  * Type initialization:
26936  * This problem is tough by the requirement that no dynamic
26937  * memory is used. Also, since swig_type_info structures store pointers to
26938  * swig_cast_info structures and swig_cast_info structures store pointers back
26939  * to swig_type_info structures, we need some lookup code at initialization.
26940  * The idea is that swig generates all the structures that are needed.
26941  * The runtime then collects these partially filled structures.
26942  * The SWIG_InitializeModule function takes these initial arrays out of
26943  * swig_module, and does all the lookup, filling in the swig_module.types
26944  * array with the correct data and linking the correct swig_cast_info
26945  * structures together.
26946  *
26947  * The generated swig_type_info structures are assigned statically to an initial
26948  * array. We just loop through that array, and handle each type individually.
26949  * First we lookup if this type has been already loaded, and if so, use the
26950  * loaded structure instead of the generated one. Then we have to fill in the
26951  * cast linked list. The cast data is initially stored in something like a
26952  * two-dimensional array. Each row corresponds to a type (there are the same
26953  * number of rows as there are in the swig_type_initial array). Each entry in
26954  * a column is one of the swig_cast_info structures for that type.
26955  * The cast_initial array is actually an array of arrays, because each row has
26956  * a variable number of columns. So to actually build the cast linked list,
26957  * we find the array of casts associated with the type, and loop through it
26958  * adding the casts to the list. The one last trick we need to do is making
26959  * sure the type pointer in the swig_cast_info struct is correct.
26960  *
26961  * First off, we lookup the cast->type name to see if it is already loaded.
26962  * There are three cases to handle:
26963  * 1) If the cast->type has already been loaded AND the type we are adding
26964  * casting info to has not been loaded (it is in this module), THEN we
26965  * replace the cast->type pointer with the type pointer that has already
26966  * been loaded.
26967  * 2) If BOTH types (the one we are adding casting info to, and the
26968  * cast->type) are loaded, THEN the cast info has already been loaded by
26969  * the previous module so we just ignore it.
26970  * 3) Finally, if cast->type has not already been loaded, then we add that
26971  * swig_cast_info to the linked list (because the cast->type) pointer will
26972  * be correct.
26973  * ----------------------------------------------------------------------------- */
26974 
26975 #ifdef __cplusplus
26976 extern "C" {
26977 #if 0
26978 } /* c-mode */
26979 #endif
26980 #endif
26981 
26982 #if 0
26983 #define SWIGRUNTIME_DEBUG
26984 #endif
26985 
26986 
26987 SWIGRUNTIME void
26988 SWIG_InitializeModule(void *clientdata) {
26989  size_t i;
26990  swig_module_info *module_head, *iter;
26991  int init;
26992 
26993  /* check to see if the circular list has been setup, if not, set it up */
26994  if (swig_module.next==0) {
26995  /* Initialize the swig_module */
26999  init = 1;
27000  } else {
27001  init = 0;
27002  }
27003 
27004  /* Try and load any already created modules */
27005  module_head = SWIG_GetModule(clientdata);
27006  if (!module_head) {
27007  /* This is the first module loaded for this interpreter */
27008  /* so set the swig module into the interpreter */
27009  SWIG_SetModule(clientdata, &swig_module);
27010  } else {
27011  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
27012  iter=module_head;
27013  do {
27014  if (iter==&swig_module) {
27015  /* Our module is already in the list, so there's nothing more to do. */
27016  return;
27017  }
27018  iter=iter->next;
27019  } while (iter!= module_head);
27020 
27021  /* otherwise we must add our module into the list */
27022  swig_module.next = module_head->next;
27023  module_head->next = &swig_module;
27024  }
27025 
27026  /* When multiple interpreters are used, a module could have already been initialized in
27027  a different interpreter, but not yet have a pointer in this interpreter.
27028  In this case, we do not want to continue adding types... everything should be
27029  set up already */
27030  if (init == 0) return;
27031 
27032  /* Now work on filling in swig_module.types */
27033 #ifdef SWIGRUNTIME_DEBUG
27034  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
27035 #endif
27036  for (i = 0; i < swig_module.size; ++i) {
27037  swig_type_info *type = 0;
27038  swig_type_info *ret;
27039  swig_cast_info *cast;
27040 
27041 #ifdef SWIGRUNTIME_DEBUG
27042  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27043 #endif
27044 
27045  /* if there is another module already loaded */
27046  if (swig_module.next != &swig_module) {
27048  }
27049  if (type) {
27050  /* Overwrite clientdata field */
27051 #ifdef SWIGRUNTIME_DEBUG
27052  printf("SWIG_InitializeModule: found type %s\n", type->name);
27053 #endif
27056 #ifdef SWIGRUNTIME_DEBUG
27057  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27058 #endif
27059  }
27060  } else {
27061  type = swig_module.type_initial[i];
27062  }
27063 
27064  /* Insert casting types */
27065  cast = swig_module.cast_initial[i];
27066  while (cast->type) {
27067 
27068  /* Don't need to add information already in the list */
27069  ret = 0;
27070 #ifdef SWIGRUNTIME_DEBUG
27071  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27072 #endif
27073  if (swig_module.next != &swig_module) {
27075 #ifdef SWIGRUNTIME_DEBUG
27076  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27077 #endif
27078  }
27079  if (ret) {
27080  if (type == swig_module.type_initial[i]) {
27081 #ifdef SWIGRUNTIME_DEBUG
27082  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27083 #endif
27084  cast->type = ret;
27085  ret = 0;
27086  } else {
27087  /* Check for casting already in the list */
27088  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27089 #ifdef SWIGRUNTIME_DEBUG
27090  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27091 #endif
27092  if (!ocast) ret = 0;
27093  }
27094  }
27095 
27096  if (!ret) {
27097 #ifdef SWIGRUNTIME_DEBUG
27098  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27099 #endif
27100  if (type->cast) {
27101  type->cast->prev = cast;
27102  cast->next = type->cast;
27103  }
27104  type->cast = cast;
27105  }
27106  cast++;
27107  }
27108  /* Set entry in modules->types array equal to the type */
27109  swig_module.types[i] = type;
27110  }
27111  swig_module.types[i] = 0;
27112 
27113 #ifdef SWIGRUNTIME_DEBUG
27114  printf("**** SWIG_InitializeModule: Cast List ******\n");
27115  for (i = 0; i < swig_module.size; ++i) {
27116  int j = 0;
27118  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
27119  while (cast->type) {
27120  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27121  cast++;
27122  ++j;
27123  }
27124  printf("---- Total casts: %d\n",j);
27125  }
27126  printf("**** SWIG_InitializeModule: Cast List ******\n");
27127 #endif
27128 }
27129 
27130 /* This function will propagate the clientdata field of type to
27131 * any new swig_type_info structures that have been added into the list
27132 * of equivalent types. It is like calling
27133 * SWIG_TypeClientData(type, clientdata) a second time.
27134 */
27135 SWIGRUNTIME void
27137  size_t i;
27138  swig_cast_info *equiv;
27139  static int init_run = 0;
27140 
27141  if (init_run) return;
27142  init_run = 1;
27143 
27144  for (i = 0; i < swig_module.size; i++) {
27145  if (swig_module.types[i]->clientdata) {
27146  equiv = swig_module.types[i]->cast;
27147  while (equiv) {
27148  if (!equiv->converter) {
27149  if (equiv->type && !equiv->type->clientdata)
27151  }
27152  equiv = equiv->next;
27153  }
27154  }
27155  }
27156 }
27157 
27158 #ifdef __cplusplus
27159 #if 0
27160 { /* c-mode */
27161 #endif
27162 }
27163 #endif
27164 
27165 
27166 
27167 static bool SWIG_init_user(octave_swig_type* module_ns);
27168 
27170  bool retn = false;
27171  {
27172 #if SWIG_OCTAVE_PREREQ(6,0,0)
27173 #elif SWIG_OCTAVE_PREREQ(4,2,0)
27174  octave::unwind_protect frame;
27175  frame.protect_var(discard_error_messages); discard_error_messages = true;
27176  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27177 #elif SWIG_OCTAVE_PREREQ(3,3,50)
27178  unwind_protect frame;
27179  frame.protect_var(error_state); error_state = 0;
27180  frame.protect_var(warning_state); warning_state = 0;
27181  frame.protect_var(discard_error_messages); discard_error_messages = true;
27182  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27183 #else
27184  unwind_protect::begin_frame("SWIG_Octave_LoadModule");
27185  unwind_protect_int(error_state); error_state = 0;
27186  unwind_protect_int(warning_state); warning_state = 0;
27187  unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27188  unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27189 #endif
27190 #if SWIG_OCTAVE_PREREQ(4,2,0)
27191  try {
27192 #if SWIG_OCTAVE_PREREQ(4,4,0)
27193  octave::feval(name, octave_value_list(), 0);
27194 #else
27195  feval(name, octave_value_list(), 0);
27196 #endif
27197  retn = true;
27198  } catch (octave::execution_exception&) { }
27199 #else
27200  feval(name, octave_value_list(), 0);
27201  retn = (error_state == 0);
27202 #endif
27203 #if !SWIG_OCTAVE_PREREQ(3,3,50)
27204  unwind_protect::run_frame("SWIG_Octave_LoadModule");
27205 #endif
27206  }
27207  if (!retn) {
27208  error(SWIG_name_d ": could not load module `%s'", name.c_str());
27209  }
27210  return retn;
27211 }
27212 
27213 SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
27214  bool retn = false;
27215  {
27216 #if SWIG_OCTAVE_PREREQ(6,0,0)
27217 #elif SWIG_OCTAVE_PREREQ(4,2,0)
27218  octave::unwind_protect frame;
27219  frame.protect_var(discard_error_messages); discard_error_messages = true;
27220  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27221 #elif SWIG_OCTAVE_PREREQ(3,3,50)
27222  unwind_protect frame;
27223  frame.protect_var(error_state); error_state = 0;
27224  frame.protect_var(warning_state); warning_state = 0;
27225  frame.protect_var(discard_error_messages); discard_error_messages = true;
27226  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
27227 #else
27228  unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
27229  unwind_protect_int(error_state); error_state = 0;
27230  unwind_protect_int(warning_state); warning_state = 0;
27231  unwind_protect_bool(discard_error_messages); discard_error_messages = true;
27232  unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
27233 #endif
27234  octave_value_list args;
27235  args.append(name);
27236  args.append(octloadfcn->fcn_file_name());
27237 #if SWIG_OCTAVE_PREREQ(4,2,0)
27238  try {
27239 #if SWIG_OCTAVE_PREREQ(4,4,0)
27240  octave::feval("autoload", args, 0);
27241 #else
27242  feval("autoload", args, 0);
27243 #endif
27244  retn = true;
27245  } catch (octave::execution_exception&) { }
27246 #else
27247  feval("autoload", args, 0);
27248  retn = (error_state == 0);
27249 #endif
27250 #if !SWIG_OCTAVE_PREREQ(3,3,50)
27251  unwind_protect::run_frame("SWIG_Octave_InstallFunction");
27252 #endif
27253  }
27254  if (!retn) {
27255  error(SWIG_name_d ": could not load function `%s'", name.c_str());
27256  }
27257  return retn;
27258 }
27259 
27260 static const char *const subclass_usage = "-*- texinfo -*- \n\
27261 @deftypefn {Loadable Function} {} subclass()\n\
27262 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
27263 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
27264 \n\
27265 See the SWIG manual for usage examples.\n\
27266 @end deftypefn";
27267 
27268 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
27270  for (int j = 0; j < args.length(); ++j) {
27271  if (args(j).type_id() == octave_swig_ref::static_type_id()) {
27272  octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
27273  octave_swig_type *ost = osr->get_ptr();
27274  if (!ost->is_owned()) {
27275  error("subclass: cannot subclass object not constructed on octave side");
27276  return octave_value_list();
27277  }
27278  top->merge(*ost);
27279  } else if (args(j).is_function_handle()) {
27280  top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
27281  } else if (args(j).is_string()) {
27282  if (j + 1 >= args.length()) {
27283  error("subclass: member assignments must be of string,value form");
27284  return octave_value_list();
27285  }
27286  top->assign(args(j).string_value(), args(j + 1));
27287  ++j;
27288  } else {
27289  error("subclass: invalid arguments to subclass()");
27290  return octave_value_list();
27291  }
27292  }
27293  return octave_value(Swig::swig_value_ref(top));
27294 }
27295 
27296 static const char *const swig_type_usage = "-*- texinfo -*- \n\
27297 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
27298 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
27299 @end deftypefn";
27300 
27301 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
27302  if (args.length() != 1) {
27303  error("swig_type: must be called with only a single object");
27304  return octave_value_list();
27305  }
27306  octave_swig_type *ost = Swig::swig_value_deref(args(0));
27307  if (!ost) {
27308  error("swig_type: object is not a swig_ref");
27309  return octave_value_list();
27310  }
27311  return octave_value(ost->swig_type_name());
27312 }
27313 
27314 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
27315 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
27316 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
27317 otherwise return `<unknown>'.\n\
27318 @end deftypefn";
27319 
27320 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
27321  if (args.length() != 1 || !args(0).is_string()) {
27322  error("swig_typequery: must be called with single string argument");
27323  return octave_value_list();
27324  }
27325  swig_module_info *module = SWIG_GetModule(0);
27326  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
27327  if (!type)
27328  return octave_value("<unknown>");
27329  return octave_value(type->name);
27330 }
27331 
27332 static const char *const swig_this_usage = "-*- texinfo -*- \n\
27333 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
27334 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
27335 @end deftypefn";
27336 
27337 DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
27338  if (args.length() != 1) {
27339  error("swig_this: must be called with only a single object");
27340  return octave_value_list();
27341  }
27342  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
27343  return octave_value(octave_uint64(0));
27344  octave_swig_type *ost = Swig::swig_value_deref(args(0));
27345  if (!ost) {
27346  error("swig_this: object is not a swig_ref");
27347  return octave_value_list();
27348  }
27349  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
27350 }
27351 
27352 static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
27353 @deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
27354 Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
27355 @end deftypefn";
27356 
27357 DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
27358  if (args.length() != 3) {
27359  error("swig_octave_prereq: must be called with 3 arguments");
27360  return octave_value_list();
27361  }
27362  const int major = args(0).int_value();
27363  const int minor = args(1).int_value();
27364  const int patch = args(2).int_value();
27365  const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
27366  return octave_value(prereq);
27367 }
27368 
27369 static const char *const swig_exit_usage = "-*- texinfo -*- \n\
27370 @deftypefn {Loadable Function} {} swig_exit([@var{exit_status}])\n\
27371 Exit Octave without performing any memory cleanup.\n\
27372 @end deftypefn";
27373 
27374 DEFUN_DLD( swig_exit, args, nargout, swig_exit_usage ) {
27375  if (args.length() > 1) {
27376  error("swig_exit: must be called with at most one arguments");
27377  return octave_value_list();
27378  }
27379  int exit_status = 0;
27380  if (args.length() == 1) {
27381  exit_status = args(0).int_value();
27382  }
27383  ::_Exit(exit_status);
27384  return octave_value();
27385 }
27386 
27387 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
27388 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
27389 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
27390 @end deftypefn";
27391 
27393 
27394  static octave_swig_type* module_ns = 0;
27395 
27396  // workaround to prevent octave seg-faulting on exit: set Octave exit function
27397  // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
27398  // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
27399  // version 3.4.*, reappeared in 4.2.*, hack not possible in 4.4.* or later due to
27400  // removal of octave_exit, so turn on for all versions between 3.2.*. and 4.4.*.
27401  // can be turned off with macro definition.
27402 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
27403 #if !SWIG_OCTAVE_PREREQ(4,4,0)
27404 #if SWIG_OCTAVE_PREREQ(3,2,0)
27405  octave_exit = ::_Exit;
27406 #endif
27407 #endif
27408 #endif
27409 
27410  // check for no input and output args
27411  if (args.length() != 0 || nargout != 0) {
27412  print_usage();
27413  return octave_value_list();
27414  }
27415 
27416  // create module on first function call
27417  if (!module_ns) {
27418 
27419  // workaround bug in octave where installing global variable of custom type and then
27420  // exiting without explicitly clearing the variable causes octave to segfault.
27421 #if SWIG_OCTAVE_PREREQ(3,2,0)
27422  octave_value_list eval_args;
27423  eval_args.append("base");
27424  eval_args.append("function __swig_atexit__; "
27425  " if mislocked() "
27426  " clear -all; "
27427  " else "
27428  " mlock(); "
27429  " endif; "
27430  "endfunction; "
27431  "__swig_atexit__; "
27432  "atexit(\"__swig_atexit__\", false); "
27433  "atexit(\"__swig_atexit__\")");
27434 #if SWIG_OCTAVE_PREREQ(4,4,0)
27435  octave::feval("evalin", eval_args, 0);
27436 #else
27437  feval("evalin", eval_args, 0);
27438 #endif
27439 #endif
27440 
27441 #if SWIG_OCTAVE_PREREQ(4,4,0)
27442  {
27443  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
27444  string_vector types = typeinfo.installed_type_names();
27445  bool register_octave_swig_ref = true;
27446  bool register_octave_swig_packed = true;
27447  for (int i = 0; i < types.numel(); ++i) {
27448  if (types(i) == octave_swig_ref::static_type_name()) {
27449  register_octave_swig_ref = false;
27450  octave_swig_ref::set_type_id(i);
27451  }
27452  if (types(i) == octave_swig_packed::static_type_name()) {
27453  register_octave_swig_packed = false;
27454  octave_swig_packed::set_type_id(i);
27455  }
27456  }
27457  if (register_octave_swig_ref) {
27458  octave_swig_ref::register_type();
27459  }
27460  if (register_octave_swig_packed) {
27461  octave_swig_packed::register_type();
27462  }
27463  }
27464 #else
27465  octave_swig_ref::register_type();
27466  octave_swig_packed::register_type();
27467 #endif
27470 
27471 #if SWIG_OCTAVE_PREREQ(6,0,0)
27472  octave::tree_evaluator& tree_eval = octave::interpreter::the_interpreter()->get_evaluator();
27473  octave::call_stack& stack = tree_eval.get_call_stack();
27474  octave_function *me = stack.current_function();
27475 #elif SWIG_OCTAVE_PREREQ(4,4,0)
27476  octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
27477  octave_function *me = stack.current();
27478 #else
27479  octave_function *me = octave_call_stack::current();
27480 #endif
27481 
27482  if (!SWIG_Octave_InstallFunction(me, "subclass")) {
27483  return octave_value_list();
27484  }
27485  if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
27486  return octave_value_list();
27487  }
27488  if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
27489  return octave_value_list();
27490  }
27491  if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
27492  return octave_value_list();
27493  }
27494  if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
27495  return octave_value_list();
27496  }
27497  if (!SWIG_Octave_InstallFunction(me, "swig_exit")) {
27498  return octave_value_list();
27499  }
27500 
27501  octave_swig_type* cvar_ns=0;
27502  if (std::string(SWIG_global_name) != ".") {
27503  cvar_ns=new octave_swig_type;
27504  for (int j=0;swig_globals[j].name;++j)
27505  if (swig_globals[j].get_method)
27506  cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
27507  }
27508 
27509  module_ns=new octave_swig_type(0, 0, 0, true);
27510  if (std::string(SWIG_global_name) != ".") {
27511  module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
27512  }
27513  else {
27514  for (int j=0;swig_globals[j].name;++j)
27515  if (swig_globals[j].get_method)
27516  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27517  }
27518  for (int j=0;swig_globals[j].name;++j)
27519  if (swig_globals[j].method)
27520  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
27521 
27522  // * need better solution here; swig_type -> octave_class mapping is
27523  // * really n-to-1, in some cases such as template partial spec, etc.
27524  // * see failing tests.
27525  for (int j=0;swig_types[j];++j)
27526  if (swig_types[j]->clientdata) {
27527  swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
27528  module_ns->assign(c->name,
27530  (new octave_swig_type(0,swig_types[j])));
27531  }
27532 
27533  if (!SWIG_init_user(module_ns)) {
27534  delete module_ns;
27535  module_ns=0;
27536  return octave_value_list();
27537  }
27538 
27539  SWIG_InstallOps(octave_swig_ref::static_type_id());
27540 
27542  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27543  if (mb->second.first && mb->second.first->method) {
27544  if (!SWIG_Octave_InstallFunction(me, mb->first)) {
27545  return octave_value_list();
27546  }
27547  }
27548  }
27549 
27550 #if SWIG_OCTAVE_PREREQ(4,4,0)
27551  octave::interpreter::the_interpreter()->mlock();
27552 #elif SWIG_OCTAVE_PREREQ(3,2,0)
27553  mlock();
27554 #else
27555  mlock(me->name());
27556 #endif
27557 
27558  }
27559 
27561  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
27562  if (mb->second.second.is_defined()) {
27563  SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
27564  SWIG_Octave_LinkGlobalValue(mb->first);
27565  }
27566  }
27567 
27570 
27571  return octave_value_list();
27572 
27573 }
27574 
27575 
27576 static bool SWIG_init_user(octave_swig_type* module_ns)
27577 {
27578  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
27579  SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
27580  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
27581  SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
27582  SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
27583  SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
27584  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
27585  SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
27586  SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
27587  SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
27588  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
27589  SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
27590  SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
27591  SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
27592  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
27593  SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
27594  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
27595  SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
27596  SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
27597  SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
27598  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
27599  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
27600  SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
27601  SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
27602  SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
27603  SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
27604  SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
27605  SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
27606  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
27607  SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
27608  SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
27609  SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
27610  SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
27611  SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
27612  SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
27613  SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
27614  SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
27615  SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
27616  SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
27617  SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
27618  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
27619  SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
27620  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
27621  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
27622  SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
27623  SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
27624  SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
27625  SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
27626  SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
27627  SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
27628  SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
27629  SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
27630  SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
27631  SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
27632  SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
27633  SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
27634  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
27635  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
27636  SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27637  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
27638  SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
27639  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
27640  SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
27641  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
27642  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
27643  SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
27644  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
27645  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
27646  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
27647  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
27648  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
27649  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
27650  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
27651  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
27652  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
27653  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
27654  SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
27655  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
27656  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
27657  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
27658  SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
27659  SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
27660  SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
27661  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
27662  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
27663  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
27664  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
27665  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
27666  SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
27667  SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
27668  SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
27669  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
27670  SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
27671  SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
27672  SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
27673  SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
27674  SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
27675  SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
27676  SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
27677  SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
27678  SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
27679  SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
27680  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
27681  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
27682  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
27683  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
27684  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
27685  SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
27686  SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
27687  SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
27688  SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
27689  SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
27690  SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
27691  SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
27692  SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
27693  SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
27694  SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
27695  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
27696  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
27697  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
27698  SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
27699  SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
27700  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
27701  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
27702  SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
27703  SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
27704  SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
27705  SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
27706  SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
27707  SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
27708  SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
27709  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
27710  SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
27711  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
27712  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
27713  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
27714  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27715  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27716  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
27717  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27718  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
27719  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
27720  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
27721  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
27722  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
27723  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
27724  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
27725  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
27726  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
27727  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
27728  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
27729  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
27730  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
27731  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
27732  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
27733  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
27734  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
27735  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
27736  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
27737  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
27738  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
27739  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
27740  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
27741  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
27742  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
27743  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
27744  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
27745  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
27746  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
27747  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
27748  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
27749  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
27750  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
27751  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
27752  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
27753  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
27754  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
27755  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
27756  SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
27757  SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
27758  SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
27759  SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
27760  SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
27761  SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
27762  SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
27763  return true;
27764 }
27765 
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 Tcl_Interp * interp
Definition: tkMain.c:120
static const char * name
Definition: tkMain.c:135