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.1
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 
12 #ifndef SWIGOCTAVE
13 #define SWIGOCTAVE
14 #endif
15 
16 #define SWIG_name_d "plplot_octave"
17 #define SWIG_name plplot_octave
18 
19 #define SWIG_global_name "cvar"
20 #define SWIG_op_prefix "op_"
21 
22 
23 #ifdef __cplusplus
24 /* SwigValueWrapper is described in swig.swg */
25 template<typename T> class SwigValueWrapper {
26  struct SwigMovePointer {
27  T *ptr;
28  SwigMovePointer(T *p) : ptr(p) { }
29  ~SwigMovePointer() { delete ptr; }
30  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
31  } pointer;
32  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
33  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
34 public:
35  SwigValueWrapper() : pointer(0) { }
36  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
37  operator T&() const { return *pointer.ptr; }
38  T *operator&() { return pointer.ptr; }
39 };
40 
41 template <typename T> T SwigValueInit() {
42  return T();
43 }
44 #endif
45 
46 /* -----------------------------------------------------------------------------
47  * This section contains generic SWIG labels for method/variable
48  * declarations/attributes, and other compiler dependent labels.
49  * ----------------------------------------------------------------------------- */
50 
51 /* template workaround for compilers that cannot correctly implement the C++ standard */
52 #ifndef SWIGTEMPLATEDISAMBIGUATOR
53 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # elif defined(__HP_aCC)
56 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
57 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
58 # define SWIGTEMPLATEDISAMBIGUATOR template
59 # else
60 # define SWIGTEMPLATEDISAMBIGUATOR
61 # endif
62 #endif
63 
64 /* inline attribute */
65 #ifndef SWIGINLINE
66 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
67 # define SWIGINLINE inline
68 # else
69 # define SWIGINLINE
70 # endif
71 #endif
72 
73 /* attribute recognised by some compilers to avoid 'unused' warnings */
74 #ifndef SWIGUNUSED
75 # if defined(__GNUC__)
76 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
77 # define SWIGUNUSED __attribute__ ((__unused__))
78 # else
79 # define SWIGUNUSED
80 # endif
81 # elif defined(__ICC)
82 # define SWIGUNUSED __attribute__ ((__unused__))
83 # else
84 # define SWIGUNUSED
85 # endif
86 #endif
87 
88 #ifndef SWIG_MSC_UNSUPPRESS_4505
89 # if defined(_MSC_VER)
90 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
91 # endif
92 #endif
93 
94 #ifndef SWIGUNUSEDPARM
95 # ifdef __cplusplus
96 # define SWIGUNUSEDPARM(p)
97 # else
98 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
99 # endif
100 #endif
101 
102 /* internal SWIG method */
103 #ifndef SWIGINTERN
104 # define SWIGINTERN static SWIGUNUSED
105 #endif
106 
107 /* internal inline SWIG method */
108 #ifndef SWIGINTERNINLINE
109 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
110 #endif
111 
112 /* exporting methods */
113 #if defined(__GNUC__)
114 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
115 # ifndef GCC_HASCLASSVISIBILITY
116 # define GCC_HASCLASSVISIBILITY
117 # endif
118 # endif
119 #endif
120 
121 #ifndef SWIGEXPORT
122 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
123 # if defined(STATIC_LINKED)
124 # define SWIGEXPORT
125 # else
126 # define SWIGEXPORT __declspec(dllexport)
127 # endif
128 # else
129 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
130 # define SWIGEXPORT __attribute__ ((visibility("default")))
131 # else
132 # define SWIGEXPORT
133 # endif
134 # endif
135 #endif
136 
137 /* calling conventions for Windows */
138 #ifndef SWIGSTDCALL
139 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
140 # define SWIGSTDCALL __stdcall
141 # else
142 # define SWIGSTDCALL
143 # endif
144 #endif
145 
146 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
147 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
148 # define _CRT_SECURE_NO_DEPRECATE
149 #endif
150 
151 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
152 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
153 # define _SCL_SECURE_NO_DEPRECATE
154 #endif
155 
156 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
157 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
158 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
159 #endif
160 
161 /* Intel's compiler complains if a variable which was never initialised is
162  * cast to void, which is a common idiom which we use to indicate that we
163  * are aware a variable isn't used. So we just silence that warning.
164  * See: https://github.com/swig/swig/issues/192 for more discussion.
165  */
166 #ifdef __INTEL_COMPILER
167 # pragma warning disable 592
168 #endif
169 
170 
171 
172 #include <cstdlib>
173 #include <iostream>
174 
175 #include <octave/oct.h>
176 #include <octave/version.h>
177 
178 // Macro for enabling features which require Octave version >= major.minor.patch
179 // - Use (OCTAVE_PATCH_VERSION + 0) to handle both '<digit>' (released) and '<digit>+' (in development) patch numbers
180 #define SWIG_OCTAVE_PREREQ(major, minor, patch) \
181  ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
182 
183 // Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
184 #if !defined(OCTAVE_MAJOR_VERSION)
185 
186 # if !defined(OCTAVE_API_VERSION_NUMBER)
187 
188 // Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
189 // introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
190 # include <octave/ov.h>
191 # if defined(octave_ov_h)
192 # define OCTAVE_MAJOR_VERSION 3
193 # define OCTAVE_MINOR_VERSION 8
194 # define OCTAVE_PATCH_VERSION 0
195 # else
196 
197 // Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
198 # define ComplexLU __ignore
199 # include <octave/CmplxLU.h>
200 # undef ComplexLU
201 # if defined(octave_Complex_LU_h)
202 
203 // We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
204 # define OCTAVE_MAJOR_VERSION 3
205 # define OCTAVE_MINOR_VERSION 1
206 # define OCTAVE_PATCH_VERSION 99
207 
208 # else
209 
210 // OCTAVE_API_VERSION_NUMBER == 37
211 # define OCTAVE_MAJOR_VERSION 3
212 # define OCTAVE_MINOR_VERSION 2
213 # define OCTAVE_PATCH_VERSION 0
214 
215 # endif // defined(octave_Complex_LU_h)
216 
217 # endif // defined(octave_ov_h)
218 
219 // Correlation between Octave API and version numbers extracted from Octave's
220 // ChangeLogs; version is the *earliest* released Octave with that API number
221 # elif OCTAVE_API_VERSION_NUMBER >= 48
222 # define OCTAVE_MAJOR_VERSION 3
223 # define OCTAVE_MINOR_VERSION 6
224 # define OCTAVE_PATCH_VERSION 0
225 
226 # elif OCTAVE_API_VERSION_NUMBER >= 45
227 # define OCTAVE_MAJOR_VERSION 3
228 # define OCTAVE_MINOR_VERSION 4
229 # define OCTAVE_PATCH_VERSION 1
230 
231 # elif OCTAVE_API_VERSION_NUMBER >= 42
232 # define OCTAVE_MAJOR_VERSION 3
233 # define OCTAVE_MINOR_VERSION 3
234 # define OCTAVE_PATCH_VERSION 54
235 
236 # elif OCTAVE_API_VERSION_NUMBER >= 41
237 # define OCTAVE_MAJOR_VERSION 3
238 # define OCTAVE_MINOR_VERSION 3
239 # define OCTAVE_PATCH_VERSION 53
240 
241 # elif OCTAVE_API_VERSION_NUMBER >= 40
242 # define OCTAVE_MAJOR_VERSION 3
243 # define OCTAVE_MINOR_VERSION 3
244 # define OCTAVE_PATCH_VERSION 52
245 
246 # elif OCTAVE_API_VERSION_NUMBER >= 39
247 # define OCTAVE_MAJOR_VERSION 3
248 # define OCTAVE_MINOR_VERSION 3
249 # define OCTAVE_PATCH_VERSION 51
250 
251 # else // OCTAVE_API_VERSION_NUMBER == 38
252 # define OCTAVE_MAJOR_VERSION 3
253 # define OCTAVE_MINOR_VERSION 3
254 # define OCTAVE_PATCH_VERSION 50
255 
256 # endif // !defined(OCTAVE_API_VERSION_NUMBER)
257 
258 #endif // !defined(OCTAVE_MAJOR_VERSION)
259 
260 #include <octave/Cell.h>
261 #include <octave/dynamic-ld.h>
262 #include <octave/oct-env.h>
263 #include <octave/oct-map.h>
264 #include <octave/ov-scalar.h>
265 #include <octave/ov-fcn-handle.h>
266 #include <octave/parse.h>
267 #if SWIG_OCTAVE_PREREQ(4,2,0)
268 #include <octave/interpreter.h>
269 #else
270 #include <octave/toplev.h>
271 #endif
272 #include <octave/unwind-prot.h>
273 #if SWIG_OCTAVE_PREREQ(4,2,0)
274 #include <octave/call-stack.h>
275 #endif
276 
277 
278 /* -----------------------------------------------------------------------------
279  * swigrun.swg
280  *
281  * This file contains generic C API SWIG runtime support for pointer
282  * type checking.
283  * ----------------------------------------------------------------------------- */
284 
285 /* This should only be incremented when either the layout of swig_type_info changes,
286  or for whatever reason, the runtime changes incompatibly */
287 #define SWIG_RUNTIME_VERSION "4"
288 
289 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
290 #ifdef SWIG_TYPE_TABLE
291 # define SWIG_QUOTE_STRING(x) #x
292 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
293 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
294 #else
295 # define SWIG_TYPE_TABLE_NAME
296 #endif
297 
298 /*
299  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
300  creating a static or dynamic library from the SWIG runtime code.
301  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
302 
303  But only do this if strictly necessary, ie, if you have problems
304  with your compiler or suchlike.
305 */
306 
307 #ifndef SWIGRUNTIME
308 # define SWIGRUNTIME SWIGINTERN
309 #endif
310 
311 #ifndef SWIGRUNTIMEINLINE
312 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
313 #endif
314 
315 /* Generic buffer size */
316 #ifndef SWIG_BUFFER_SIZE
317 # define SWIG_BUFFER_SIZE 1024
318 #endif
319 
320 /* Flags for pointer conversions */
321 #define SWIG_POINTER_DISOWN 0x1
322 #define SWIG_CAST_NEW_MEMORY 0x2
323 #define SWIG_POINTER_NO_NULL 0x4
324 
325 /* Flags for new pointer objects */
326 #define SWIG_POINTER_OWN 0x1
327 
328 
329 /*
330  Flags/methods for returning states.
331 
332  The SWIG conversion methods, as ConvertPtr, return an integer
333  that tells if the conversion was successful or not. And if not,
334  an error code can be returned (see swigerrors.swg for the codes).
335 
336  Use the following macros/flags to set or process the returning
337  states.
338 
339  In old versions of SWIG, code such as the following was usually written:
340 
341  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
342  // success code
343  } else {
344  //fail code
345  }
346 
347  Now you can be more explicit:
348 
349  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
350  if (SWIG_IsOK(res)) {
351  // success code
352  } else {
353  // fail code
354  }
355 
356  which is the same really, but now you can also do
357 
358  Type *ptr;
359  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
360  if (SWIG_IsOK(res)) {
361  // success code
362  if (SWIG_IsNewObj(res) {
363  ...
364  delete *ptr;
365  } else {
366  ...
367  }
368  } else {
369  // fail code
370  }
371 
372  I.e., now SWIG_ConvertPtr can return new objects and you can
373  identify the case and take care of the deallocation. Of course that
374  also requires SWIG_ConvertPtr to return new result values, such as
375 
376  int SWIG_ConvertPtr(obj, ptr,...) {
377  if (<obj is ok>) {
378  if (<need new object>) {
379  *ptr = <ptr to new allocated object>;
380  return SWIG_NEWOBJ;
381  } else {
382  *ptr = <ptr to old object>;
383  return SWIG_OLDOBJ;
384  }
385  } else {
386  return SWIG_BADOBJ;
387  }
388  }
389 
390  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
391  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
392  SWIG errors code.
393 
394  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
395  allows to return the 'cast rank', for example, if you have this
396 
397  int food(double)
398  int fooi(int);
399 
400  and you call
401 
402  food(1) // cast rank '1' (1 -> 1.0)
403  fooi(1) // cast rank '0'
404 
405  just use the SWIG_AddCast()/SWIG_CheckState()
406 */
407 
408 #define SWIG_OK (0)
409 #define SWIG_ERROR (-1)
410 #define SWIG_IsOK(r) (r >= 0)
411 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
412 
413 /* The CastRankLimit says how many bits are used for the cast rank */
414 #define SWIG_CASTRANKLIMIT (1 << 8)
415 /* The NewMask denotes the object was created (using new/malloc) */
416 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
417 /* The TmpMask is for in/out typemaps that use temporal objects */
418 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
419 /* Simple returning values */
420 #define SWIG_BADOBJ (SWIG_ERROR)
421 #define SWIG_OLDOBJ (SWIG_OK)
422 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
423 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
424 /* Check, add and del mask methods */
425 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
426 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
427 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
428 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
429 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
430 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
431 
432 /* Cast-Rank Mode */
433 #if defined(SWIG_CASTRANK_MODE)
434 # ifndef SWIG_TypeRank
435 # define SWIG_TypeRank unsigned long
436 # endif
437 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
438 # define SWIG_MAXCASTRANK (2)
439 # endif
440 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
441 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
442 SWIGINTERNINLINE int SWIG_AddCast(int r) {
443  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
444 }
446  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
447 }
448 #else /* no cast-rank mode */
449 # define SWIG_AddCast(r) (r)
450 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
451 #endif
452 
453 
454 #include <string.h>
455 
456 #ifdef __cplusplus
457 extern "C" {
458 #endif
459 
460 typedef void *(*swig_converter_func)(void *, int *);
461 typedef struct swig_type_info *(*swig_dycast_func)(void **);
462 
463 /* Structure to store information on one type */
464 typedef struct swig_type_info {
465  const char *name; /* mangled name of this type */
466  const char *str; /* human readable name of this type */
467  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
468  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
469  void *clientdata; /* language specific type data */
470  int owndata; /* flag if the structure owns the clientdata */
472 
473 /* Structure to store a type and conversion function used for casting */
474 typedef struct swig_cast_info {
475  swig_type_info *type; /* pointer to type that is equivalent to this type */
476  swig_converter_func converter; /* function to cast the void pointers */
477  struct swig_cast_info *next; /* pointer to next cast in linked list */
478  struct swig_cast_info *prev; /* pointer to the previous cast */
480 
481 /* Structure used to store module information
482  * Each module generates one structure like this, and the runtime collects
483  * all of these structures and stores them in a circularly linked list.*/
484 typedef struct swig_module_info {
485  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
486  size_t size; /* Number of types in this module */
487  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
488  swig_type_info **type_initial; /* Array of initially generated type structures */
489  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
490  void *clientdata; /* Language specific module data */
492 
493 /*
494  Compare two type names skipping the space characters, therefore
495  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
496 
497  Return 0 when the two name types are equivalent, as in
498  strncmp, but skipping ' '.
499 */
500 SWIGRUNTIME int
501 SWIG_TypeNameComp(const char *f1, const char *l1,
502  const char *f2, const char *l2) {
503  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
504  while ((*f1 == ' ') && (f1 != l1)) ++f1;
505  while ((*f2 == ' ') && (f2 != l2)) ++f2;
506  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
507  }
508  return (int)((l1 - f1) - (l2 - f2));
509 }
510 
511 /*
512  Check type equivalence in a name list like <name1>|<name2>|...
513  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
514 */
515 SWIGRUNTIME int
516 SWIG_TypeCmp(const char *nb, const char *tb) {
517  int equiv = 1;
518  const char* te = tb + strlen(tb);
519  const char* ne = nb;
520  while (equiv != 0 && *ne) {
521  for (nb = ne; *ne; ++ne) {
522  if (*ne == '|') break;
523  }
524  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
525  if (*ne) ++ne;
526  }
527  return equiv;
528 }
529 
530 /*
531  Check type equivalence in a name list like <name1>|<name2>|...
532  Return 0 if not equal, 1 if equal
533 */
534 SWIGRUNTIME int
535 SWIG_TypeEquiv(const char *nb, const char *tb) {
536  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
537 }
538 
539 /*
540  Check the typename
541 */
543 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
544  if (ty) {
545  swig_cast_info *iter = ty->cast;
546  while (iter) {
547  if (strcmp(iter->type->name, c) == 0) {
548  if (iter == ty->cast)
549  return iter;
550  /* Move iter to the top of the linked list */
551  iter->prev->next = iter->next;
552  if (iter->next)
553  iter->next->prev = iter->prev;
554  iter->next = ty->cast;
555  iter->prev = 0;
556  if (ty->cast) ty->cast->prev = iter;
557  ty->cast = iter;
558  return iter;
559  }
560  iter = iter->next;
561  }
562  }
563  return 0;
564 }
565 
566 /*
567  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
568 */
571  if (ty) {
572  swig_cast_info *iter = ty->cast;
573  while (iter) {
574  if (iter->type == from) {
575  if (iter == ty->cast)
576  return iter;
577  /* Move iter to the top of the linked list */
578  iter->prev->next = iter->next;
579  if (iter->next)
580  iter->next->prev = iter->prev;
581  iter->next = ty->cast;
582  iter->prev = 0;
583  if (ty->cast) ty->cast->prev = iter;
584  ty->cast = iter;
585  return iter;
586  }
587  iter = iter->next;
588  }
589  }
590  return 0;
591 }
592 
593 /*
594  Cast a pointer up an inheritance hierarchy
595 */
596 SWIGRUNTIMEINLINE void *
597 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
598  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
599 }
600 
601 /*
602  Dynamic pointer casting. Down an inheritance hierarchy
603 */
606  swig_type_info *lastty = ty;
607  if (!ty || !ty->dcast) return ty;
608  while (ty && (ty->dcast)) {
609  ty = (*ty->dcast)(ptr);
610  if (ty) lastty = ty;
611  }
612  return lastty;
613 }
614 
615 /*
616  Return the name associated with this type
617 */
618 SWIGRUNTIMEINLINE const char *
620  return ty->name;
621 }
622 
623 /*
624  Return the pretty name associated with this type,
625  that is an unmangled type name in a form presentable to the user.
626 */
627 SWIGRUNTIME const char *
629  /* The "str" field contains the equivalent pretty names of the
630  type, separated by vertical-bar characters. We choose
631  to print the last name, as it is often (?) the most
632  specific. */
633  if (!type) return NULL;
634  if (type->str != NULL) {
635  const char *last_name = type->str;
636  const char *s;
637  for (s = type->str; *s; s++)
638  if (*s == '|') last_name = s+1;
639  return last_name;
640  }
641  else
642  return type->name;
643 }
644 
645 /*
646  Set the clientdata field for a type
647 */
648 SWIGRUNTIME void
650  swig_cast_info *cast = ti->cast;
651  /* if (ti->clientdata == clientdata) return; */
652  ti->clientdata = clientdata;
653 
654  while (cast) {
655  if (!cast->converter) {
656  swig_type_info *tc = cast->type;
657  if (!tc->clientdata) {
659  }
660  }
661  cast = cast->next;
662  }
663 }
664 SWIGRUNTIME void
667  ti->owndata = 1;
668 }
669 
670 /*
671  Search for a swig_type_info structure only by mangled name
672  Search is a O(log #types)
673 
674  We start searching at module start, and finish searching when start == end.
675  Note: if start == end at the beginning of the function, we go all the way around
676  the circular list.
677 */
680  swig_module_info *end,
681  const char *name) {
682  swig_module_info *iter = start;
683  do {
684  if (iter->size) {
685  size_t l = 0;
686  size_t r = iter->size - 1;
687  do {
688  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
689  size_t i = (l + r) >> 1;
690  const char *iname = iter->types[i]->name;
691  if (iname) {
692  int compare = strcmp(name, iname);
693  if (compare == 0) {
694  return iter->types[i];
695  } else if (compare < 0) {
696  if (i) {
697  r = i - 1;
698  } else {
699  break;
700  }
701  } else if (compare > 0) {
702  l = i + 1;
703  }
704  } else {
705  break; /* should never happen */
706  }
707  } while (l <= r);
708  }
709  iter = iter->next;
710  } while (iter != end);
711  return 0;
712 }
713 
714 /*
715  Search for a swig_type_info structure for either a mangled name or a human readable name.
716  It first searches the mangled names of the types, which is a O(log #types)
717  If a type is not found it then searches the human readable names, which is O(#types).
718 
719  We start searching at module start, and finish searching when start == end.
720  Note: if start == end at the beginning of the function, we go all the way around
721  the circular list.
722 */
725  swig_module_info *end,
726  const char *name) {
727  /* STEP 1: Search the name field using binary search */
728  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
729  if (ret) {
730  return ret;
731  } else {
732  /* STEP 2: If the type hasn't been found, do a complete search
733  of the str field (the human readable name) */
734  swig_module_info *iter = start;
735  do {
736  size_t i = 0;
737  for (; i < iter->size; ++i) {
738  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
739  return iter->types[i];
740  }
741  iter = iter->next;
742  } while (iter != end);
743  }
744 
745  /* neither found a match */
746  return 0;
747 }
748 
749 /*
750  Pack binary data into a string
751 */
752 SWIGRUNTIME char *
753 SWIG_PackData(char *c, void *ptr, size_t sz) {
754  static const char hex[17] = "0123456789abcdef";
755  const unsigned char *u = (unsigned char *) ptr;
756  const unsigned char *eu = u + sz;
757  for (; u != eu; ++u) {
758  unsigned char uu = *u;
759  *(c++) = hex[(uu & 0xf0) >> 4];
760  *(c++) = hex[uu & 0xf];
761  }
762  return c;
763 }
764 
765 /*
766  Unpack binary data from a string
767 */
768 SWIGRUNTIME const char *
769 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
770  unsigned char *u = (unsigned char *) ptr;
771  const unsigned char *eu = u + sz;
772  for (; u != eu; ++u) {
773  char d = *(c++);
774  unsigned char uu;
775  if ((d >= '0') && (d <= '9'))
776  uu = (unsigned char)((d - '0') << 4);
777  else if ((d >= 'a') && (d <= 'f'))
778  uu = (unsigned char)((d - ('a'-10)) << 4);
779  else
780  return (char *) 0;
781  d = *(c++);
782  if ((d >= '0') && (d <= '9'))
783  uu |= (unsigned char)(d - '0');
784  else if ((d >= 'a') && (d <= 'f'))
785  uu |= (unsigned char)(d - ('a'-10));
786  else
787  return (char *) 0;
788  *u = uu;
789  }
790  return c;
791 }
792 
793 /*
794  Pack 'void *' into a string buffer.
795 */
796 SWIGRUNTIME char *
797 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
798  char *r = buff;
799  if ((2*sizeof(void *) + 2) > bsz) return 0;
800  *(r++) = '_';
801  r = SWIG_PackData(r,&ptr,sizeof(void *));
802  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
803  strcpy(r,name);
804  return buff;
805 }
806 
807 SWIGRUNTIME const char *
808 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
809  if (*c != '_') {
810  if (strcmp(c,"NULL") == 0) {
811  *ptr = (void *) 0;
812  return name;
813  } else {
814  return 0;
815  }
816  }
817  return SWIG_UnpackData(++c,ptr,sizeof(void *));
818 }
819 
820 SWIGRUNTIME char *
821 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
822  char *r = buff;
823  size_t lname = (name ? strlen(name) : 0);
824  if ((2*sz + 2 + lname) > bsz) return 0;
825  *(r++) = '_';
826  r = SWIG_PackData(r,ptr,sz);
827  if (lname) {
828  strncpy(r,name,lname+1);
829  } else {
830  *r = 0;
831  }
832  return buff;
833 }
834 
835 SWIGRUNTIME const char *
836 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
837  if (*c != '_') {
838  if (strcmp(c,"NULL") == 0) {
839  memset(ptr,0,sz);
840  return name;
841  } else {
842  return 0;
843  }
844  }
845  return SWIG_UnpackData(++c,ptr,sz);
846 }
847 
848 #ifdef __cplusplus
849 }
850 #endif
851 
852 /* Errors in SWIG */
853 #define SWIG_UnknownError -1
854 #define SWIG_IOError -2
855 #define SWIG_RuntimeError -3
856 #define SWIG_IndexError -4
857 #define SWIG_TypeError -5
858 #define SWIG_DivisionByZero -6
859 #define SWIG_OverflowError -7
860 #define SWIG_SyntaxError -8
861 #define SWIG_ValueError -9
862 #define SWIG_SystemError -10
863 #define SWIG_AttributeError -11
864 #define SWIG_MemoryError -12
865 #define SWIG_NullReferenceError -13
866 
867 
868 
869 #if !SWIG_OCTAVE_PREREQ(3,2,0)
870 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
871 #else
872 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
873 #endif
874 
875 SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
876  if (num_args > max_args && !varargs)
877  error("function %s takes at most %i arguments", func_name, max_args);
878  else if (num_args < min_args)
879  error("function %s requires at least %i arguments", func_name, min_args);
880  else
881  return true;
882  return false;
883 }
884 
885 SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
886  ovl->append(ov);
887  return ovl;
888 }
889 
890 SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
891  switch (code) {
892  case SWIG_MemoryError:
893  return "SWIG_MemoryError";
894  case SWIG_IOError:
895  return "SWIG_IOError";
896  case SWIG_RuntimeError:
897  return "SWIG_RuntimeError";
898  case SWIG_IndexError:
899  return "SWIG_IndexError";
900  case SWIG_TypeError:
901  return "SWIG_TypeError";
902  case SWIG_DivisionByZero:
903  return "SWIG_DivisionByZero";
904  case SWIG_OverflowError:
905  return "SWIG_OverflowError";
906  case SWIG_SyntaxError:
907  return "SWIG_SyntaxError";
908  case SWIG_ValueError:
909  return "SWIG_ValueError";
910  case SWIG_SystemError:
911  return "SWIG_SystemError";
912  case SWIG_AttributeError:
913  return "SWIG_AttributeError";
914  }
915  return "SWIG unknown error";
916 }
917 
918 SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
919  octave_value type(SWIG_ErrorType(code));
920  std::string r = msg;
921  r += " (" + type.string_value() + ")";
922  error("%s", r.c_str());
923  return octave_value(r);
924 }
925 
926 #define SWIG_fail goto fail
927 
928 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
929 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
930 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
931 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
932 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
933 #define swig_owntype int
934 
935 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
936 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
937 
938 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
939 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
940 
941 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
942 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
943 
944 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
945 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
946 #define SWIG_MODULE_CLIENTDATA_TYPE void*
947 
948 #define Octave_Error_Occurred() 0
949 #define SWIG_Octave_AddErrorMsg(msg) {;}
950 
953 
954 // For backward compatibility only
955 #define SWIG_POINTER_EXCEPTION 0
956 #define SWIG_arg_fail(arg) 0
957 
958 // Runtime API implementation
959 
960 #include <map>
961 #include <vector>
962 #include <string>
963 
964 typedef octave_value_list(*octave_func) (const octave_value_list &, int);
965 class octave_swig_type;
966 
967 namespace Swig {
968 
969 #ifdef SWIG_DIRECTORS
970 
971  class Director;
972 
973  typedef std::map < void *, Director * > rtdir_map;
974  SWIGINTERN rtdir_map* get_rtdir_map();
975  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
976  SWIGINTERNINLINE void erase_rtdir(void *vptr);
977  SWIGINTERNINLINE Director *get_rtdir(void *vptr);
978 
979  SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
980  SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
981  SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
982 
983 #endif
984 
985  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
987  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
988 }
989 
990 #ifdef SWIG_DIRECTORS
991 SWIGRUNTIME void swig_acquire_ownership(void *vptr);
992 SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
993 SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
994 #endif
995 
997  const char *name;
1001  int flags; // 1 static, 2 global
1002  const char *doc;
1003  bool is_static() const {
1004  return flags &1;
1005  } bool is_global() const {
1006  return flags &2;
1007  }
1008  };
1009 
1011  const char *name;
1015  const char *constructor_doc;
1018  const char **base_names;
1020  };
1021 
1022 #if SWIG_OCTAVE_PREREQ(4,4,0)
1023  // in Octave 4.4 behaviour of octave_builtin() appears to have changed and 'self' argument is no longer passed
1024  // to function (maybe because this is now a 'method'??) so need to create our own octave_function subclass
1025 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1026  class octave_swig_bound_func : public octave_function {
1027  public:
1028 
1029  octave_swig_bound_func(void) : octave_function(), method(0), first_args()
1030  { }
1031 
1032  octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1033  : octave_function("", ""), method(_method), first_args(_first_args)
1034  { }
1035 
1036  octave_swig_bound_func(const octave_swig_bound_func& f) = delete;
1037 
1038  octave_swig_bound_func& operator= (const octave_swig_bound_func& f) = delete;
1039 
1040  ~octave_swig_bound_func(void) = default;
1041 
1042  bool is_function(void) const { return true; }
1043 
1044  octave_function* function_value(bool = false) { return this; }
1045 
1046  octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1047  octave_value_list all_args;
1048  all_args.append(first_args);
1049  all_args.append(args);
1050  return method->call(tw, nargout, all_args);
1051  }
1052 
1053  octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1054  octave_value_list ovl = subsref(ops, idx, 1);
1055  return ovl.length() ? ovl(0) : octave_value();
1056  }
1057 
1058  octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1059  assert(ops.size() > 0);
1060  assert(ops.size() == idx.size());
1061  if (ops != "(")
1062  error("invalid function call");
1063  octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1064  return call(tw, nargout, *idx.begin());
1065  }
1066 
1067  protected:
1068 
1069  octave_function* method;
1070  octave_value_list first_args;
1071 
1072  std::set<std::string> dispatch_classes;
1073 
1074  private:
1075 
1076  DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
1077  };
1078  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_bound_func, "octave_swig_bound_func", "octave_swig_bound_func");
1079 #else
1080 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1081 #endif
1082 
1083  // octave_swig_type plays the role of both the shadow class and the class
1084  // representation within Octave, since there is no support for classes.
1085  //
1086  // These should really be decoupled, with the class support added to Octave
1087  // and the shadow class given by an m-file script. That would dramatically
1088  // reduce the runtime complexity, and be more in line w/ other modules.
1089 
1090  class octave_swig_type:public octave_base_value {
1091  struct cpp_ptr {
1092  void *ptr;
1094  cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1095  }};
1096  typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1097 
1099 
1100  const swig_type_info *construct_type; // type of special type object
1101  std::vector < type_ptr_pair > types; // our c++ base classes
1102  int own; // whether we call c++ destructors when we die
1103 
1104  typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1105  typedef std::map < std::string, member_value_pair > member_map;
1108 
1109  const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
1110  if (!type->clientdata)
1111  return 0;
1113  const swig_octave_member *m;
1114  for (m = c->members; m->name; ++m)
1115  if (m->name == name)
1116  return m;
1117  for (int j = 0; c->base_names[j]; ++j) {
1118  if (!c->base[j]) {
1119  if (!module)
1120  module = SWIG_GetModule(0);
1121  assert(module);
1123  }
1124  if (!c->base[j])
1125  return 0;
1126  if ((m = find_member(c->base[j], name)))
1127  return m;
1128  }
1129  return 0;
1130  }
1131 
1132  member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1133  member_map::iterator it = members.find(name);
1134  if (it != members.end())
1135  return &it->second;
1136  const swig_octave_member *m;
1137  for (unsigned int j = 0; j < types.size(); ++j)
1138  if ((m = find_member(types[j].first, name)))
1139  return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1140  if (!insert_if_not_found)
1141  return 0;
1142  return &members[name];
1143  }
1144 
1145  const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
1146  if (!base) {
1147  for (unsigned int j = 0; j < types.size(); ++j) {
1148  assert(types[j].first->clientdata);
1149  swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1150  if (cj->name == name)
1151  return types[j].first;
1152  }
1153  return 0;
1154  }
1155  assert(base->clientdata);
1157  for (int j = 0; c->base_names[j]; ++j) {
1158  if (!c->base[j]) {
1159  if (!module)
1160  module = SWIG_GetModule(0);
1161  assert(module);
1163  }
1164  if (!c->base[j])
1165  return 0;
1166  assert(c->base[j]->clientdata);
1168  if (cj->name == name)
1169  return c->base[j];
1170  }
1171  return 0;
1172  }
1173 
1174  void load_members(const swig_octave_class* c,member_map& out) const {
1175  for (const swig_octave_member *m = c->members; m->name; ++m) {
1176  if (out.find(m->name) == out.end())
1177  out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1178  }
1179  for (int j = 0; c->base_names[j]; ++j) {
1180  if (!c->base[j]) {
1181  if (!module)
1182  module = SWIG_GetModule(0);
1183  assert(module);
1185  }
1186  if (!c->base[j])
1187  continue;
1188  assert(c->base[j]->clientdata);
1189  const swig_octave_class *cj =
1190  (const swig_octave_class *) c->base[j]->clientdata;
1191  load_members(cj,out);
1192  }
1193  }
1194 
1195  void load_members(member_map& out) const {
1196  out=members;
1197  for (unsigned int j = 0; j < types.size(); ++j)
1198  if (types[j].first->clientdata)
1199  load_members((const swig_octave_class *) types[j].first->clientdata, out);
1200  }
1201 
1202  octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1203  if (m->second.is_defined())
1204  return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1205  else if (m->first && m->first->method)
1206  return m->first->method(args, nargout);
1207  error("member not defined or not invocable");
1208  return octave_value_list();
1209  }
1210 
1211  bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
1212  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1213  member_value_pair *m = nc_this->find_member(symbol, false);
1214  if (!m || m->first->is_static() || m->first->is_global())
1215  return false;
1216  octave_value_list args;
1217  args.append(nc_this->as_value());
1218  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1219  if (argout.length() < 1)
1220  return false;
1221  ret = argout(0);
1222  return true;
1223  }
1224 
1225  bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
1226  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1227  member_value_pair *m = nc_this->find_member(symbol, false);
1228  if (!m || m->first->is_static() || m->first->is_global())
1229  return false;
1230  octave_value_list args;
1231  args.append(nc_this->as_value());
1232  args.append(make_value_hack(rhs));
1233  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1234  if (argout.length() < 1)
1235  return false;
1236  ret = argout(0);
1237  return true;
1238  }
1239 
1240  bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
1241  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1242  member_value_pair *m = nc_this->find_member(symbol, false);
1243  if (!m || m->first->is_static() || m->first->is_global())
1244  return false;
1245  octave_value_list args;
1246  args.append(nc_this->as_value());
1247  args.append(rhs);
1248  octave_value_list argout(nc_this->member_invoke(m, args, 1));
1249  if (argout.length() >= 1)
1250  ret = argout(0);
1251  return true;
1252  }
1253 
1254  octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1255  if (m->second.is_defined()) {
1256  if (m->second.is_function() || m->second.is_function_handle()) {
1257  return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args);
1258  } else {
1259  return m->second;
1260  }
1261  } else if (m->first) {
1262  if (m->first->get_method)
1263  return m->first->get_method(args, 1);
1264  else if (m->first->method)
1265  return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args);
1266  }
1267  error("undefined member");
1268  return octave_value_list();
1269  }
1270 
1271  static octave_value make_value_hack(const octave_base_value &x) {
1272  ((octave_swig_type &) x).count++;
1273  return octave_value((octave_base_value *) &x);
1274  }
1275 
1278  public:
1279 
1280  octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1281  bool _always_static = false)
1282  : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1283  always_static(_always_static) {
1284  if (_type || _ptr)
1285  types.push_back(std::make_pair(_type, _ptr));
1286 #ifdef SWIG_DIRECTORS
1287  if (_ptr) {
1288  Swig::Director *d = Swig::get_rtdir(_ptr);
1289  if (d)
1290  Swig::swig_director_set_self(d, this);
1291  }
1292 #endif
1293  }
1294 
1296  if (own) {
1297  ++count;
1298  for (unsigned int j = 0; j < types.size(); ++j) {
1299  if (!types[j].first || !types[j].first->clientdata)
1300  continue;
1301  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1302  if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1303  c->destructor(as_value(), 0);
1304  }
1305  }
1306  }
1307 #ifdef SWIG_DIRECTORS
1308  for (unsigned int j = 0; j < types.size(); ++j)
1309  Swig::erase_rtdir(types[j].second.ptr);
1310 #endif
1311  }
1312 
1313  dim_vector dims(void) const {
1314  octave_value out;
1315  if (!dispatch_unary_op("__dims__", out))
1316  return dim_vector(1,1);
1317 
1318  // Return value should be cell or matrix of integers
1319 #if SWIG_OCTAVE_PREREQ(4,4,0)
1320  if (out.iscell()) {
1321 #else
1322  if (out.is_cell()) {
1323 #endif
1324  const Cell & c=out.cell_value();
1325  int ndim = c.rows();
1326  if (ndim==1 && c.columns()!=1) ndim = c.columns();
1327 
1328  dim_vector d;
1329  d.resize(ndim < 2 ? 2 : ndim);
1330  d(0) = d(1) = 1;
1331 
1332  // Fill in dim_vector
1333  for (int k=0;k<ndim;k++) {
1334  const octave_value& obj = c(k);
1335  d.elem(k) = obj.int_value();
1336 
1337  // __dims__ should return a cell filled with integers
1338  if (error_state) return dim_vector(1,1);
1339  }
1340  return d;
1341 #if SWIG_OCTAVE_PREREQ(4,4,0)
1342  } else if (out.is_matrix_type() || out.isnumeric() ) {
1343 #else
1344  } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1345 #endif
1346  if (out.rows()==1 || out.columns()==1) {
1347  Array<int> a = out.int_vector_value();
1348  if (error_state) return dim_vector(1,1);
1349  dim_vector d;
1350  d.resize(a.numel() < 2 ? 2 : a.numel());
1351  d(0) = d(1) = 1;
1352  for (int k=0;k<a.numel();k++) {
1353  d.elem(k) = a(k);
1354  }
1355  return d;
1356  } else {
1357  return dim_vector(1,1);
1358  }
1359  } else {
1360  return dim_vector(1,1);
1361  }
1362  }
1363 
1364  octave_value as_value() {
1365  ++count;
1366  return Swig::swig_value_ref(this);
1367  }
1368 
1369  void incref() {
1370  ++count;
1371  }
1372 
1373  void decref() {
1374  if (!--count)
1375  delete this;
1376  }
1377 
1378  long swig_this() const {
1379  if (!types.size())
1380  return (long) this;
1381  return (long) types[0].second.ptr;
1382  }
1383  const char* help_text() const {
1384  if (!types.size())
1385  return 0;
1386  if (!types[0].first->clientdata)
1387  return 0;
1388  swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1389  return c->constructor_doc;
1390  }
1391 
1392  std::string swig_type_name() const {
1393  // * need some way to manually name subclasses.
1394  // * eg optional first arg to subclass(), or named_subclass()
1395  std::string ret;
1396  for (unsigned int j = 0; j < types.size(); ++j) {
1397  if (j)
1398  ret += "_";
1399  if (types[j].first->clientdata) {
1400  swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1401  ret += c->name;
1402  } else
1403  ret += types[j].first->name;
1404  }
1405  return ret;
1406  }
1407 
1409  rhs.own = 0;
1410  for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1411  assert(!rhs.types[j].second.destroyed);
1412 #ifdef SWIG_DIRECTORS
1413  Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1414  if (d)
1415  Swig::swig_director_set_self(d, this);
1416 #endif
1417  }
1418  types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1419  members.insert(rhs.members.begin(), rhs.members.end());
1420 #if SWIG_OCTAVE_PREREQ(4,4,0)
1421  assign(rhs.swig_type_name(), rhs.as_value());
1422 #else
1423  rhs.types.clear();
1424  rhs.members.clear();
1425 #endif
1426  }
1427 
1428  typedef member_map::const_iterator swig_member_const_iterator;
1431 
1432  int cast(void **vptr, swig_type_info *type, int *_own, int flags) {
1433  int res = SWIG_ERROR;
1434  if (_own)
1435  *_own = own;
1436  if (flags &SWIG_POINTER_DISOWN)
1437  own = 0;
1438  if (!type && types.size()) {
1439  if(vptr)
1440  *vptr = types[0].second.ptr;
1441  return SWIG_OK;
1442  }
1443  for (unsigned int j = 0; j < types.size(); ++j)
1444  if (type == types[j].first) {
1445  if(vptr)
1446  *vptr = types[j].second.ptr;
1447  return SWIG_OK;
1448  }
1449  for (unsigned int j = 0; j < types.size(); ++j) {
1450  swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1451  if (!tc)
1452  continue;
1453  if(vptr) {
1454  int newmemory = 0;
1455  *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1456  if (newmemory == SWIG_CAST_NEW_MEMORY) {
1457  assert(_own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1458  if (_own)
1459  *_own = *_own | SWIG_CAST_NEW_MEMORY;
1460  }
1461  }
1462  res = SWIG_OK;
1463  break;
1464  }
1465  return res;
1466  }
1467 
1468  bool is_owned() const {
1469  return own;
1470  }
1471 
1472 #ifdef SWIG_DIRECTORS
1473  void director_destroyed(Swig::Director *d) {
1474  bool found = false;
1475  for (unsigned int j = 0; j < types.size(); ++j) {
1476  Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1477  if (dj == d) {
1478  types[j].second.destroyed = true;
1479  found = true;
1480  }
1481  }
1482  assert(found);
1483  }
1484 #endif
1485 
1486  void assign(const std::string &name, const octave_value &ov) {
1487  members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1488  }
1489 
1490  void assign(const std::string &name, const swig_octave_member *m) {
1491  members[name] = std::make_pair(m, octave_value());
1492  }
1493 
1494  octave_base_value *clone() const {
1495  // pass-by-value is probably not desired, and is harder;
1496  // requires calling copy constructors of contained types etc.
1497  assert(0);
1498  *(int *) 0 = 0;
1499  return 0;
1500  }
1501 
1502  octave_base_value *empty_clone() const {
1503  return new octave_swig_type();
1504  }
1505 
1506  bool is_defined() const {
1507  return true;
1508  }
1509 
1510  virtual bool is_map() const {
1511  return true;
1512  }
1513 
1514  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1515  octave_value_list ovl = subsref(ops, idx, 1);
1516  return ovl.length()? ovl(0) : octave_value();
1517  }
1518 
1519  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1520  assert(ops.size() > 0);
1521  assert(ops.size() == idx.size());
1522 
1523  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1524  int skip = 0;
1525  octave_value_list sub_ovl;
1526 
1527  // constructor invocation
1528  if (ops[skip] == '(' && construct_type) {
1529  assert(construct_type->clientdata);
1531  if (!c->constructor) {
1532  error("cannot create instance");
1533  return octave_value_list();
1534  }
1535  octave_value_list args;
1536  if (c->director)
1537  args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1538  args.append(*idx_it++);
1539  ++skip;
1540  sub_ovl = c->constructor(args, nargout);
1541  }
1542  // member dereference or invocation
1543  else if (ops[skip] == '.') {
1544  std::string subname;
1545  const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1546  for (;;) {
1547  octave_value_list subname_ovl(*idx_it++);
1548  ++skip;
1549  assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1550  subname = subname_ovl(0).string_value();
1551 
1552  const swig_type_info *next_base = find_base(subname, base);
1553  if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1554  break;
1555  base = next_base;
1556  }
1557 
1558  member_value_pair tmp, *m = &tmp;
1559  if (!base || !(m->first = find_member(base, subname)))
1560  m = find_member(subname, false);
1561  if (!m) {
1562  error("member not found");
1563  return octave_value_list();
1564  }
1565 
1566  octave_value_list args;
1567  if (!always_static &&
1568  (!m->first || (!m->first->is_static() && !m->first->is_global())))
1569  args.append(as_value());
1570  if (skip < (int) ops.size() && ops[skip] == '(' &&
1571  ((m->first && m->first->method) || m->second.is_function() ||
1572  m->second.is_function_handle())) {
1573  args.append(*idx_it++);
1574  ++skip;
1575  sub_ovl = member_invoke(m, args, nargout);
1576  } else {
1577  sub_ovl = member_deref(m, args);
1578  }
1579  }
1580  // index operator
1581  else {
1582  if (ops[skip] == '(' || ops[skip] == '{') {
1583  const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1584  octave_value_list args;
1585  args.append(*idx_it++);
1586  ++skip;
1587  if (!dispatch_index_op(op_name, args, sub_ovl)) {
1588  error("error evaluating index operator");
1589  return octave_value_list();
1590  }
1591  } else {
1592  error("unsupported subsref");
1593  return octave_value_list();
1594  }
1595  }
1596 
1597  if (skip >= (int) ops.size())
1598  return sub_ovl;
1599  if (sub_ovl.length() < 1) {
1600  error("bad subs ref");
1601  return octave_value_list();
1602  }
1603  return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1604  }
1605 
1606  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1607  assert(ops.size() > 0);
1608  assert(ops.size() == idx.size());
1609 
1610  std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1611  int skip = 0;
1612 
1613  if (ops.size() > 1) {
1614  std::list < octave_value_list >::const_iterator last = idx.end();
1615  --last;
1616  std::list < octave_value_list > next_idx(idx.begin(), last);
1617  octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1618  next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1619  }
1620 
1621  else if (ops[skip] == '(' || ops[skip] == '{') {
1622  const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1623  member_value_pair *m = find_member(op_name, false);
1624  if (m) {
1625  octave_value_list args;
1626  args.append(as_value());
1627  args.append(*idx_it);
1628  args.append(rhs);
1629  member_invoke(m, args, 1);
1630  } else
1631  error("%s member not found", op_name);
1632  }
1633 
1634  else if (ops[skip] == '.') {
1635  octave_value_list subname_ovl(*idx_it++);
1636  ++skip;
1637  assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1638  std::string subname = subname_ovl(0).string_value();
1639 
1640  member_value_pair *m = find_member(subname, true);
1641  if (!m->first || !m->first->set_method) {
1642  m->first = 0;
1643  m->second = rhs;
1644  } else if (m->first->set_method) {
1645  octave_value_list args;
1646  if (!m->first->is_static() && !m->first->is_global())
1647  args.append(as_value());
1648  args.append(rhs);
1649  m->first->set_method(args, 1);
1650  } else
1651  error("member not assignable");
1652  } else
1653  error("unsupported subsasgn");
1654 
1655  return as_value();
1656  }
1657 
1658  virtual bool is_object() const {
1659  return true;
1660  }
1661 
1662  virtual bool is_string() const {
1663  octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1664  return !!nc_this->find_member("__str__", false);
1665  }
1666 
1667  virtual std::string string_value(bool force = false) const {
1668  octave_value ret;
1669  if (!dispatch_unary_op("__str__", ret)) {
1670  error("__str__ method not defined");
1671  return std::string();
1672  }
1673  if (!ret.is_string()) {
1674  error("__str__ method did not return a string");
1675  return std::string();
1676  }
1677  return ret.string_value();
1678  }
1679 
1680  virtual double scalar_value(bool frc_str_conv = false) const {
1681  octave_value ret;
1682  if (!dispatch_unary_op("__float__", ret)) {
1683  error("__float__ method not defined");
1684  }
1685  return ret.scalar_value();
1686  }
1687 
1688 #if SWIG_OCTAVE_PREREQ(4,2,0)
1689  virtual octave_value as_double(void) const {
1690  octave_value ret;
1691  if (!dispatch_unary_op("__float__", ret)) {
1692  error("__float__ method not defined");
1693  }
1694  return ret.as_double();
1695  }
1696 
1697  virtual octave_value as_single(void) const {
1698  octave_value ret;
1699  if (!dispatch_unary_op("__float__", ret)) {
1700  error("__float__ method not defined");
1701  }
1702  return ret.as_single();
1703  }
1704 #endif
1705 
1706 #if SWIG_OCTAVE_PREREQ(3,8,0)
1707  virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
1708  const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
1709  octave_value ret;
1710  if (!dispatch_unary_op(opname, ret)) {
1711  error("%s", (opname + std::string(" method not found")).c_str());
1712  return octave_value();
1713  }
1714  return ret;
1715  }
1716 #endif
1717 
1718 #if SWIG_OCTAVE_PREREQ(3,3,52)
1719  virtual octave_map map_value() const {
1720  return octave_map();
1721  }
1722 #else
1723  virtual Octave_map map_value() const {
1724  return Octave_map();
1725  }
1726 #endif
1727 
1728  virtual string_vector map_keys() const {
1729  member_map tmp;
1730  load_members(tmp);
1731 
1732  string_vector keys(tmp.size());
1733  int k = 0;
1734  for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1735  keys(k++) = it->first;
1736 
1737  return keys;
1738  }
1739 
1740  virtual bool save_ascii (std::ostream& os) {
1741  return true;
1742  }
1743 
1744  virtual bool load_ascii (std::istream& is) {
1745  return true;
1746  }
1747 
1748  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1749  return true;
1750  }
1751 
1752  virtual bool load_binary (std::istream& is, bool swap,
1753  oct_mach_info::float_format fmt) {
1754  return true;
1755  }
1756 
1757 #if defined (HAVE_HDF5)
1758 # if SWIG_OCTAVE_PREREQ(4,0,0)
1759  virtual bool
1760  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
1761  return true;
1762  }
1763 
1764  virtual bool
1765  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
1766  return true;
1767  }
1768 # else
1769  virtual bool
1770  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1771  return true;
1772  }
1773 
1774  virtual bool
1775  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1776  return true;
1777  }
1778 # endif
1779 #endif
1780 
1781  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1782  return string_value();
1783  }
1784 
1785  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1786  return string_value();
1787  }
1788 
1789  static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1790  // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1791  // (rather than any module namespace).
1792 
1793  octave_function *fcn = is_valid_function(symbol, std::string(), false);
1794  if (!fcn)
1795  return false;
1796 #if SWIG_OCTAVE_PREREQ(4,4,0)
1797  octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1798  octave_value_list retval = fcn->call(tw, 1, args);
1799  if (retval.length() == 1)
1800  ret = retval(0);
1801 #else
1802  ret = fcn->do_multi_index_op(1, args)(0);
1803 #endif
1804  return true;
1805  }
1806 
1807  static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1809  assert(ost);
1810 
1811  octave_value ret;
1812  if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1813  return ret;
1814  std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1815  octave_value_list args;
1816  args.append(make_value_hack(x));
1817  if (dispatch_global_op(symbol, args, ret))
1818  return ret;
1819 
1820  error("could not dispatch unary operator");
1821  return octave_value();
1822  }
1823 
1824  static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1825  octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
1826  octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
1827 
1828  octave_value ret;
1829  if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1830  return ret;
1831  if (rhs_ost) {
1832  if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1833  if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1834  return ret;
1835  if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1836  return ret;
1837  }
1838  if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1839  return ret;
1840  }
1841 
1842  std::string symbol;
1843  octave_value_list args;
1844  args.append(make_value_hack(lhs));
1845  args.append(make_value_hack(rhs));
1846 
1847  symbol = SWIG_op_prefix;
1848  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1849  symbol += "_";
1850  symbol += op_name;
1851  symbol += "_";
1852  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1853  if (dispatch_global_op(symbol, args, ret))
1854  return ret;
1855 
1856  symbol = SWIG_op_prefix;
1857  symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1858  symbol += "_";
1859  symbol += op_name;
1860  symbol += "_";
1861  symbol += "any";
1862  if (dispatch_global_op(symbol, args, ret))
1863  return ret;
1864 
1865  symbol = SWIG_op_prefix;
1866  symbol += "any";
1867  symbol += "_";
1868  symbol += op_name;
1869  symbol += "_";
1870  symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1871  if (dispatch_global_op(symbol, args, ret))
1872  return ret;
1873 
1874  error("could not dispatch binary operator");
1875  return octave_value();
1876  }
1877 
1878 #if SWIG_OCTAVE_PREREQ(4,0,0)
1879  void print(std::ostream &os, bool pr_as_read_syntax = false)
1880 #else
1881  void print(std::ostream &os, bool pr_as_read_syntax = false) const
1882 #endif
1883  {
1884  if (is_string()) {
1885  os << string_value();
1886  return;
1887  }
1888 
1889  member_map tmp;
1890  load_members(tmp);
1891 
1892  indent(os);
1893  os << "{"; newline(os);
1894  increment_indent_level();
1895  for (unsigned int j = 0; j < types.size(); ++j) {
1896  indent(os);
1897  if (types[j].first->clientdata) {
1898  const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1899  os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1900  } else {
1901  os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1902  }
1903  }
1904  for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1905  indent(os);
1906  if (it->second.first) {
1907  const char *objtype = it->second.first->method ? "method" : "variable";
1908  const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1909  os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1910  assert(it->second.first->name == it->first);
1911  } else {
1912  os << it->first; newline(os);
1913  }
1914  }
1915  decrement_indent_level();
1916  indent(os);
1917  os << "}"; newline(os);
1918  }
1919  };
1920 
1921  // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1922  // will call clone() via make_unique() if there is more than one outstanding
1923  // reference to the lhs, and forces the clone's reference count to 1
1924  // (so you can't just increment your own count and return this).
1925  //
1926  // One way to fix this (without modifying Octave) is to add a level of
1927  // indirection such that clone copies ref-counted pointer and we keep
1928  // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1929  //
1930  // Supporting both pass-by-{ref,value} and toggling via %feature/option
1931  // might be nice.
1932 
1933  class octave_swig_ref:public octave_base_value {
1935  public:
1937  :ptr(_ptr) { }
1938 
1940  { if (ptr) ptr->decref(); }
1941 
1943  { return ptr; }
1944 
1945  octave_base_value *clone() const
1946  { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
1947 
1948  octave_base_value *empty_clone() const
1949  { return new octave_swig_ref(0); }
1950 
1951  dim_vector dims(void) const
1952  { return ptr->dims(); }
1953 
1954  bool is_defined() const
1955  { return ptr->is_defined(); }
1956 
1957  virtual bool is_map() const
1958  { return ptr->is_map(); }
1959 
1960  virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
1961  { return ptr->subsref(ops, idx); }
1962 
1963  virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
1964  { return ptr->subsref(ops, idx, nargout); }
1965 
1966  octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
1967  { return ptr->subsasgn(ops, idx, rhs); }
1968 
1969  virtual bool is_object() const
1970  { return ptr->is_object(); }
1971 
1972  virtual bool is_string() const
1973  { return ptr->is_string(); }
1974 
1975  virtual std::string string_value(bool force = false) const
1976  { return ptr->string_value(force); }
1977 
1978  virtual double scalar_value(bool frc_str_conv = false) const
1979  { return ptr->scalar_value(frc_str_conv); }
1980 
1981 #if SWIG_OCTAVE_PREREQ(4,2,0)
1982  virtual octave_value as_double(void) const
1983  { return ptr->as_double(); }
1984 
1985  virtual octave_value as_single(void) const
1986  { return ptr->as_single(); }
1987 #endif
1988 
1989 #if SWIG_OCTAVE_PREREQ(3,8,0)
1990  virtual octave_value map(octave_base_value::unary_mapper_t umap) const
1991  { return ptr->map(umap); }
1992 #endif
1993 
1994 #if SWIG_OCTAVE_PREREQ(3,3,52)
1995  virtual octave_map map_value() const
1996  { return ptr->map_value(); }
1997 #else
1998  virtual Octave_map map_value() const
1999  { return ptr->map_value(); }
2000 #endif
2001 
2002  virtual string_vector map_keys() const
2003  { return ptr->map_keys(); }
2004 
2005  virtual bool save_ascii (std::ostream& os)
2006  { return ptr->save_ascii(os); }
2007 
2008  virtual bool load_ascii (std::istream& is)
2009  { return ptr->load_ascii(is); }
2010 
2011  virtual bool save_binary (std::ostream& os, bool& save_as_floats)
2012  { return ptr->save_binary(os, save_as_floats); }
2013 
2014  virtual bool load_binary (std::istream& is, bool swap,
2015  oct_mach_info::float_format fmt)
2016  { return ptr->load_binary(is, swap, fmt); }
2017 
2018 #if defined (HAVE_HDF5)
2019 # if SWIG_OCTAVE_PREREQ(4,0,0)
2020  virtual bool
2021  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
2022  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2023 
2024  virtual bool
2025  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
2026  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2027 # else
2028  virtual bool
2029  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
2030  { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2031 
2032  virtual bool
2033  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
2034  { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2035 # endif
2036 #endif
2037 
2038  virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
2039  { return ptr->convert_to_str(pad, force, type); }
2040 
2041  virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
2042  { return ptr->convert_to_str_internal(pad, force, type); }
2043 
2044 #if SWIG_OCTAVE_PREREQ(4,0,0)
2045  void print(std::ostream &os, bool pr_as_read_syntax = false)
2046 #else
2047  void print(std::ostream &os, bool pr_as_read_syntax = false) const
2048 #endif
2049  { return ptr->print(os, pr_as_read_syntax); }
2050 
2051  virtual type_conv_info numeric_conversion_function(void) const {
2052  return octave_base_value::type_conv_info (default_numeric_conversion_function,
2053  octave_scalar::static_type_id ());
2054  }
2055 
2056  private:
2057  static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
2058  const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
2059  return new octave_scalar(v.scalar_value());
2060  }
2061 
2062 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2064 #endif
2066  };
2067 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2069 #endif
2070  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
2071 
2072  class octave_swig_packed:public octave_base_value {
2074  std::vector < char > buf;
2075  public:
2076 
2077  octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
2078  : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
2079  }
2080 
2081  bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
2082  if (outtype && outtype != type)
2083  return false;
2084  assert(sz <= buf.size());
2085  std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
2086  return true;
2087  }
2088 
2089  octave_base_value *clone() const {
2090  return new octave_swig_packed(*this);
2091  }
2092 
2093  octave_base_value *empty_clone() const {
2094  return new octave_swig_packed();
2095  }
2096 
2097  bool is_defined() const {
2098  return true;
2099  }
2100 
2101 #if SWIG_OCTAVE_PREREQ(4,0,0)
2102  void print(std::ostream &os, bool pr_as_read_syntax = false)
2103 #else
2104  void print(std::ostream &os, bool pr_as_read_syntax = false) const
2105 #endif
2106  {
2107  indent(os);
2108  os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
2109  }
2110 
2111 
2112  virtual bool save_ascii (std::ostream& os) {
2113  return true;
2114  }
2115 
2116  virtual bool load_ascii (std::istream& is) {
2117  return true;
2118  }
2119 
2120  virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
2121  return true;
2122  }
2123 
2124  virtual bool load_binary (std::istream& is, bool swap,
2125  oct_mach_info::float_format fmt) {
2126  return true;
2127  }
2128 
2129 #if defined (HAVE_HDF5)
2130 # if SWIG_OCTAVE_PREREQ(4,0,0)
2131  virtual bool
2132  save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
2133  return true;
2134  }
2135 
2136  virtual bool
2137  load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
2138  return true;
2139  }
2140 # else
2141  virtual bool
2142  save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
2143  return true;
2144  }
2145 
2146  virtual bool
2147  load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
2148  return true;
2149  }
2150 # endif
2151 #endif
2152 
2153  private:
2154 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2156 #endif
2158  };
2159 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2161 #endif
2162  DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
2163 
2164  SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
2165  error("attempt to set immutable member variable");
2166  return octave_value_list();
2167  }
2168 
2170  const octave_value_list &ovl;
2171  int j;
2172 
2173  octave_value_ref(const octave_value_list &_ovl, int _j)
2174  :ovl(_ovl), j(_j) { }
2175 
2176  operator octave_value() const {
2177  return ovl(j);
2178  }
2179 
2180  octave_value operator*() const {
2181  return ovl(j);
2182  }
2183  };
2184 
2185 
2186 namespace Swig {
2187 
2188  SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
2189  return new octave_swig_ref(ost);
2190  }
2191 
2193  if (
2194 #if SWIG_OCTAVE_PREREQ(4,4,0)
2195  ov.iscell()
2196 #else
2197  ov.is_cell()
2198 #endif
2199  && ov.rows() == 1 && ov.columns() == 1)
2200  ov = ov.cell_value()(0);
2201  return swig_value_deref(*ov.internal_rep());
2202  }
2203 
2204  SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
2205  if (ov.type_id() != octave_swig_ref::static_type_id())
2206  return 0;
2207  const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2208  return osr->get_ptr();
2209  }
2210 
2211 }
2212 
2213 
2214 #define swig_unary_op(name) \
2215 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2216  return octave_swig_type::dispatch_unary_op(x,#name); \
2217 }
2218 #define swig_binary_op(name) \
2219 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2220  return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2221 }
2222 #if SWIG_OCTAVE_PREREQ(4,4,0)
2223 #define swigreg_unary_op(name) \
2224 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2225 typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2226 #else
2227 #define swigreg_unary_op(name) \
2228 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2229 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2230 #endif
2231 #if SWIG_OCTAVE_PREREQ(4,4,0)
2232 #define swigreg_binary_op(name) \
2233 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2234 typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2235 #else
2236 #define swigreg_binary_op(name) \
2237 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2238 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2239 #endif
2240 
2241  swig_unary_op(not);
2242  swig_unary_op(uplus);
2243  swig_unary_op(uminus);
2244  swig_unary_op(transpose);
2245  swig_unary_op(hermitian);
2246  swig_unary_op(incr);
2247  swig_unary_op(decr);
2248 
2249  swig_binary_op(add);
2250  swig_binary_op(sub);
2251  swig_binary_op(mul);
2252  swig_binary_op(div);
2253  swig_binary_op(pow);
2254  swig_binary_op(ldiv);
2255 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2256  swig_binary_op(lshift);
2257  swig_binary_op(rshift);
2258 #endif
2259  swig_binary_op(lt);
2260  swig_binary_op(le);
2261  swig_binary_op(eq);
2262  swig_binary_op(ge);
2263  swig_binary_op(gt);
2264  swig_binary_op(ne);
2265  swig_binary_op(el_mul);
2266  swig_binary_op(el_div);
2267  swig_binary_op(el_pow);
2268  swig_binary_op(el_ldiv);
2269  swig_binary_op(el_and);
2270  swig_binary_op(el_or);
2271 
2273 #if SWIG_OCTAVE_PREREQ(4,4,0)
2274  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2275 #endif
2276  swigreg_unary_op(not);
2277  swigreg_unary_op(uplus);
2278  swigreg_unary_op(uminus);
2279  swigreg_unary_op(transpose);
2280  swigreg_unary_op(hermitian);
2281  swigreg_unary_op(incr);
2282  swigreg_unary_op(decr);
2283  }
2284  SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2285 #if SWIG_OCTAVE_PREREQ(4,4,0)
2286  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2287 #endif
2288  swigreg_binary_op(add);
2289  swigreg_binary_op(sub);
2290  swigreg_binary_op(mul);
2291  swigreg_binary_op(div);
2292  swigreg_binary_op(pow);
2293  swigreg_binary_op(ldiv);
2294 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2295  swigreg_binary_op(lshift);
2296  swigreg_binary_op(rshift);
2297 #endif
2298  swigreg_binary_op(lt);
2299  swigreg_binary_op(le);
2300  swigreg_binary_op(eq);
2301  swigreg_binary_op(ge);
2302  swigreg_binary_op(gt);
2303  swigreg_binary_op(ne);
2304  swigreg_binary_op(el_mul);
2305  swigreg_binary_op(el_div);
2306  swigreg_binary_op(el_pow);
2307  swigreg_binary_op(el_ldiv);
2308  swigreg_binary_op(el_and);
2309  swigreg_binary_op(el_or);
2310  }
2312  // here we assume that tid are conseq integers increasing from zero, and
2313  // that our tid is the last one. might be better to have explicit string
2314  // list of types we should bind to, and use lookup_type to resolve their tid.
2315 
2316  SWIG_InstallUnaryOps(tid);
2317  SWIG_InstallBinaryOps(tid, tid);
2318  for (int j = 0; j < tid; ++j) {
2319  SWIG_InstallBinaryOps(j, tid);
2320  SWIG_InstallBinaryOps(tid, j);
2321  }
2322  }
2323 
2324 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2325  int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2326 
2327 #ifdef SWIG_DIRECTORS
2328  Swig::Director *d = Swig::get_rtdir(ptr);
2329  if (d && Swig::swig_director_get_self(d))
2330  return Swig::swig_director_get_self(d)->as_value();
2331 #endif
2332  return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2333 }
2334 
2335 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2336  if (
2337 #if SWIG_OCTAVE_PREREQ(4,4,0)
2338  ov.iscell()
2339 #else
2340  ov.is_cell()
2341 #endif
2342  && ov.rows() == 1 && ov.columns() == 1)
2343  ov = ov.cell_value()(0);
2344  if (!ov.is_defined() ||
2345  (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2346  if (ptr)
2347  *ptr = 0;
2349  }
2350  if (ov.type_id() != octave_swig_ref::static_type_id())
2351  return SWIG_ERROR;
2352  octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2353  octave_swig_type *ost = osr->get_ptr();
2354  return ost->cast(ptr, type, own, flags);
2355 }
2356 
2357 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2358  return new octave_swig_packed(type, (char *) ptr, sz);
2359 }
2360 
2361 SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2362  if (!ov.is_defined())
2363  return SWIG_ERROR;
2364  if (ov.type_id() != octave_swig_packed::static_type_id())
2365  return SWIG_ERROR;
2366  octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2367  return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2368 }
2369 
2370 SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2371  module_ns->assign(name, ov);
2372 }
2373 
2375 #if SWIG_OCTAVE_PREREQ(4,4,0)
2376  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2377  return symtab.global_varval(name);
2378 #else
2379  return get_global_value(name, true);
2380 #endif
2381 }
2382 
2383 SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2384 #if SWIG_OCTAVE_PREREQ(4,4,0)
2385  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2386  symtab.global_assign(name, value);
2387 #else
2388  set_global_value(name, value);
2389 #endif
2390 }
2391 
2393 #if SWIG_OCTAVE_PREREQ(4,4,0)
2394  octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2395  octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2396  symscope.assign(name, symtab.global_varval(name));
2397  symscope.mark_global(name);
2398 #else
2399 #if !SWIG_OCTAVE_PREREQ(3,2,0)
2400  link_to_global_variable(curr_sym_tab->lookup(name, true));
2401 #else
2402 #if !SWIG_OCTAVE_PREREQ(3,8,0)
2403  symbol_table::varref(name);
2404 #endif
2405  symbol_table::mark_global(name);
2406 #endif
2407 #endif
2408 }
2409 
2411  octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2412  if (!ov.is_defined() ||
2413  ov.type_id() != octave_swig_packed::static_type_id())
2414  return 0;
2415  const octave_swig_packed* osp =
2416  static_cast < const octave_swig_packed *> (ov.internal_rep());
2417  swig_module_info *pointer = 0;
2418  osp->copy(0, &pointer, sizeof(swig_module_info *));
2419  return pointer;
2420 }
2421 
2422 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2423  octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2425 }
2426 
2427 
2428 
2429 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2430 
2431 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2432 
2433 
2434 
2435 /* -------- TYPES TABLE (BEGIN) -------- */
2436 
2437 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2438 #define SWIGTYPE_p_char swig_types[1]
2439 #define SWIGTYPE_p_double swig_types[2]
2440 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2441 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2442 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2443 #define SWIGTYPE_p_int swig_types[6]
2444 #define SWIGTYPE_p_p_char swig_types[7]
2445 #define SWIGTYPE_p_unsigned_int swig_types[8]
2447 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2448 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2449 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2450 
2451 /* -------- TYPES TABLE (END) -------- */
2452 
2453 
2454 #define SWIGVERSION 0x040001
2455 #define SWIG_VERSION SWIGVERSION
2456 
2457 
2458 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2459 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2460 
2461 
2462 #include <stdexcept>
2463 
2464 
2465 // #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2466 #undef PACKAGE
2467 #undef VERSION
2468 
2469 #include "plplotP.h"
2470 
2471 // Temporary fix for problems with -fvisibility=hidden and octave headers.
2472 #ifdef OCTAVE_EXPORT
2473  #if defined ( __GNUC__ ) && __GNUC__ > 3
2474  #undef OCTAVE_EXPORT
2475  #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2476  #endif
2477 #endif
2478 
2479 
2480 
2481 // I hate global variables but this is the best way I can think of
2482 // to manage consistency checking among function arguments.
2483  static PLINT Alen = 0;
2484  static PLINT Xlen = 0, Ylen = 0;
2485 
2486 
2487 // Convenience functions copied from matwrap-based approach (currently
2488 // stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2489 // tricky scalar case and also adopted so that the resulting
2490 // swig-generated source code will look similar to the matwrap-generated
2491 // source code.
2492 
2493  inline int max( int a, int b )
2494  {
2495  return a >= b ? a : b;
2496  }
2497  inline int min( int a, int b )
2498  {
2499  return a >= b ? a : b;
2500  }
2501 
2502 //
2503 // Function to get the total length (rows*columns) of an octave object of
2504 // arbitrary type.
2505 // Arguments:
2506 // 1) The octave object.
2507 //
2508 // If the object is a scalar, the array length is 1.
2509 //
2510  static int
2511  _arraylen( const octave_value &o_obj )
2512  {
2513  return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2514  // max is necessary because sometimes
2515  // rows() or columns() return -1 or 0 for
2516  // scalars.
2517  }
2518 
2519 //
2520 // Function to get the number of dimensions of an object.
2521 //
2522  static int
2523  _n_dims( const octave_value &o_obj )
2524  {
2525  if ( max( o_obj.columns(), 1 ) > 1 )
2526  return 2;
2527  // max is necessary because sometimes
2528  // rows() or columns() return -1 or 0 for
2529  // scalars.
2530  else if ( max( o_obj.rows(), 1 ) > 1 )
2531  return 1;
2532  else
2533  return 0;
2534  }
2535 
2536 //
2537 // Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2538 //
2539  static inline int
2540  _dim( const octave_value &o_obj, int dim_idx )
2541  {
2542  if ( dim_idx == 0 )
2543  return max( o_obj.rows(), 0 );
2544  // max is necessary because sometimes
2545  // rows() or columns() return -1 or 0 for
2546  // scalars.
2547  else if ( dim_idx == 1 )
2548  return max( o_obj.columns(), 0 );
2549  else
2550  return 1;
2551  }
2552 
2553 //
2554 // The following function converts an array of doubles into some other
2555 // numeric type. Arguments:
2556 // 1) Where to store the result. The type is determined from the type of
2557 // this pointer.
2558 // 2) A vector of doubles to convert.
2559 // 3) The number of doubles.
2560 //
2561  template <class FLOAT>
2562  static inline void
2563  _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2564  {
2565  while ( n_el-- > 0 )
2566  *out_arr++ = (FLOAT) ( *in_arr++ );
2567  }
2568 
2569  template void _cvt_double_to( int *, double *, unsigned );
2570  template void _cvt_double_to( unsigned *, double *, unsigned );
2571  template void _cvt_double_to( long *, double *, unsigned );
2572  template void _cvt_double_to( unsigned long *, double *, unsigned );
2573  template void _cvt_double_to( short *, double *, unsigned );
2574  template void _cvt_double_to( unsigned short *, double *, unsigned );
2575  template void _cvt_double_to( float *, double *, unsigned );
2576  // Instantiate our templates. Octave uses
2577  // manual template instantiation.
2578 
2579 //
2580 // Convert an array of some other type into an array of doubles. Arguments:
2581 // 1) The array of objects of other type.
2582 // 2) The output array of doubles.
2583 // 3) The number of elements to convert.
2584 //
2585  template <class FLOAT>
2586  static inline void
2587  _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2588  {
2589  while ( n_el-- > 0 )
2590  *d_arr++ = double(*arr++);
2591  }
2592 
2593  template void _cvt_to_double( int *, double *, unsigned );
2594  template void _cvt_to_double( unsigned *, double *, unsigned );
2595  template void _cvt_to_double( long *, double *, unsigned );
2596  template void _cvt_to_double( unsigned long *, double *, unsigned );
2597  template void _cvt_to_double( short *, double *, unsigned );
2598  template void _cvt_to_double( unsigned short *, double *, unsigned );
2599  template void _cvt_to_double( float *, double *, unsigned );
2600  // Instantiate our templates. Octave uses
2601  // manual template instantiation.
2602 
2603 
2604  typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2605  typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2606  typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2607  typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2608  typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2610  typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2611 
2612 
2613 #include <iostream>
2614 
2615  octave_function *fcnMapForm;
2616  std::string nameMapForm;
2617 
2618  void mapform_octave( PLINT n, PLFLT *x, PLFLT *y )
2619  {
2620  octave_idx_type i;
2621  octave_value_list functionArguments;
2622  octave_value_list retval;
2623 
2624  Matrix xin( n, 1 );
2625  Matrix yin( n, 1 );
2626  Matrix xout;
2627  Matrix yout;
2628 
2629  for ( i = 0; i < n; i++ )
2630  {
2631  xin( i, 0 ) = x[i];
2632  yin( i, 0 ) = y[i];
2633  }
2634 
2635  functionArguments( 0 ) = xin;
2636  functionArguments( 1 ) = yin;
2637 
2638  if ( fcnMapForm != NULL )
2639 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2640  retval = octave::feval( fcnMapForm, functionArguments, 1 );
2641 #else
2642  retval = feval( fcnMapForm, functionArguments, 1 );
2643 #endif
2644  else
2645 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2646  retval = octave::feval( nameMapForm, functionArguments, 1 );
2647 #else
2648  retval = feval( nameMapForm, functionArguments, 1 );
2649 #endif
2650 
2651  if ( retval.length() >= 2 )
2652  {
2653  xout = retval( 0 ).matrix_value();
2654  yout = retval( 1 ).matrix_value();
2655 
2656  for ( i = 0; i < n; i++ )
2657  {
2658  x[i] = xout( i, 0 );
2659  y[i] = yout( i, 0 );
2660  }
2661  }
2662  }
2663 
2664 
2665  octave_function *fcnLabelFunc;
2666  std::string nameLabelFunc;
2667 
2668  void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2669  {
2670  int i;
2671  octave_value_list functionArguments;
2672  octave_value_list retval;
2673 
2674  Matrix inAxis( 1, 1 );
2675  Matrix inValue( 1, 1 );
2676  inAxis( 0, 0 ) = axis;
2677  inValue( 0, 0 ) = value;
2678 
2679  functionArguments( 0 ) = inAxis;
2680  functionArguments( 1 ) = inValue;
2681 
2682  if ( fcnLabelFunc != NULL )
2683 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2684  retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2685 #else
2686  retval = feval( fcnLabelFunc, functionArguments, 1 );
2687 #endif
2688  else
2689 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2690  retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2691 #else
2692  retval = feval( nameLabelFunc, functionArguments, 1 );
2693 #endif
2694 
2695  strncpy( label, retval( 0 ).string_value().c_str(), length );
2696  }
2697 
2698 
2699  octave_function *fcnCoordTrans;
2700  std::string nameCoordTrans;
2701 
2702  void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2703  {
2704  octave_idx_type i;
2705  octave_value_list functionArguments;
2706  octave_value_list retval;
2707 
2708  Matrix xin( 1, 1 );
2709  Matrix yin( 1, 1 );
2710  Matrix xout;
2711  Matrix yout;
2712 
2713  xin( 0, 0 ) = x;
2714  yin( 0, 0 ) = y;
2715 
2716  functionArguments( 0 ) = xin;
2717  functionArguments( 1 ) = yin;
2718 
2719  if ( fcnCoordTrans != NULL )
2720 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2721  retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2722 #else
2723  retval = feval( fcnCoordTrans, functionArguments, 1 );
2724 #endif
2725  else
2726 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2727  retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2728 #else
2729  retval = feval( nameCoordTrans, functionArguments, 1 );
2730 #endif
2731 
2732  if ( retval.length() >= 2 )
2733  {
2734  xout = retval( 0 ).matrix_value();
2735  yout = retval( 1 ).matrix_value();
2736 
2737  *xt = xout( 0, 0 );
2738  *yt = yout( 0, 0 );
2739  }
2740  }
2741 
2742 
2743  void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2744  {
2745  PLINT i;
2746  printf( "nlegend =%d\n", nlegend );
2747  for ( i = 0; i < nlegend; i++ )
2748  {
2749  printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2750  printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2751  printf( "text[%d] =%s\n", i, text[i] );
2752  }
2753  }
2754 
2755 
2756 #include <limits.h>
2757 #if !defined(SWIG_NO_LLONG_MAX)
2758 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2759 # define LLONG_MAX __LONG_LONG_MAX__
2760 # define LLONG_MIN (-LLONG_MAX - 1LL)
2761 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2762 # endif
2763 #endif
2764 
2765 
2766  SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2767  {
2768  if (!ov.is_scalar_type())
2769  return SWIG_TypeError;
2770  if (ov.is_complex_scalar())
2771  return SWIG_TypeError;
2772  if (ov.is_double_type()||ov.is_single_type()) {
2773  double v=ov.double_value();
2774  if (v!=floor(v))
2775  return SWIG_TypeError;
2776  }
2777  if (val)
2778  *val = ov.long_value();
2779  return SWIG_OK;
2780  }
2781 
2782 
2783 SWIGINTERN int
2784 SWIG_AsVal_int (octave_value obj, int *val)
2785 {
2786  long v;
2787  int res = SWIG_AsVal_long (obj, &v);
2788  if (SWIG_IsOK(res)) {
2789  if ((v < INT_MIN || v > INT_MAX)) {
2790  return SWIG_OverflowError;
2791  } else {
2792  if (val) *val = static_cast< int >(v);
2793  }
2794  }
2795  return res;
2796 }
2797 
2798 
2799  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 )
2800  {
2801  PLGraphicsIn gin;
2802  int status; status = plGetCursor( &gin );
2803  *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2804  strncpy( string, gin.string, PL_MAXKEY - 1 );
2805  string[PL_MAXKEY - 1] = '\0';
2806 
2807  *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2808  return status;
2809  }
2810 
2811 
2812 SWIGINTERN int
2813 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2814 {
2815  if (
2816 #if SWIG_OCTAVE_PREREQ(4,4,0)
2817  ov.iscell()
2818 #else
2819  ov.is_cell()
2820 #endif
2821  && ov.rows() == 1 && ov.columns() == 1)
2822  ov = ov.cell_value()(0);
2823  if (!ov.is_string())
2824  return SWIG_TypeError;
2825 
2826  std::string str=ov.string_value();
2827  size_t len=str.size();
2828  char* cstr=(char*)str.c_str();
2829  if (alloc) {
2830  *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
2831  *alloc = SWIG_NEWOBJ;
2832  } else if (cptr)
2833  *cptr = cstr;
2834  if (psize)
2835  *psize = len + 1;
2836  return SWIG_OK;
2837 }
2838 
2839 
2840 
2841 
2842 
2844  {
2845  return octave_value(value);
2846  }
2847 
2848 
2849 SWIGINTERNINLINE octave_value
2851 {
2852  return SWIG_From_long (value);
2853 }
2854 
2855 
2857  {
2858  return octave_value(value);
2859  }
2860 
2861 
2862 // Translates relative device coordinates to world coordinates.
2863  static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2864  {
2865  PLGraphicsIn gin;
2866  int st;
2867  gin.dX = x_in; gin.dY = y_in;
2868  st = plTranslateCursor( &gin );
2869  *x = gin.wX; *y = gin.wY;
2870  return st;
2871  }
2872 
2873 
2874  SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2875  {
2876  if (!ov.is_scalar_type())
2877  return SWIG_TypeError;
2878  if (ov.is_complex_scalar())
2879  return SWIG_TypeError;
2880  if (val)
2881  *val = ov.double_value();
2882  return SWIG_OK;
2883  }
2884 
2885 
2886 // Create 1d stripchart
2887 
2888  void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
2889  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2890  PLFLT xlpos, PLFLT ylpos,
2891  PLBOOL y_ascl, PLBOOL acc,
2892  PLINT colbox, PLINT collab,
2893  const PLINT *colline, const PLINT *styline,
2894  const char *legline1, const char *legline2, const char *legline3, const char *legline4,
2895  const char *labx, const char *laby, const char *labtop )
2896  {
2897  const char *legline[4];
2898  legline[0] = legline1; legline[1] = legline2;
2899  legline[2] = legline3; legline[3] = legline4;
2900  c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2901  xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2902  labx, laby, labtop );
2903  }
2904 
2905 
2906 // One more hack. As it is not possible (and would not be desirable) to pass
2907 // an Octave function to plcont(), I have defined three plcont():
2908 // plcont uses a defined here xform()
2909 // plcont0 uses pltr0()
2910 // plcont1 uses pltr1()
2911 // plcont2 uses pltr2()
2912 // plcont2p uses pltr2p()
2913 //
2914 // Also, as plplot expect vectorized bidimensional arrays, I provided a
2915 // f2c, which is a #define that does the necessary conversion.
2916 //
2917 
2918  void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
2919  {
2920  *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2921  *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2922  }
2923 
2924 // convert from Fortran like arrays (one vector), to C like 2D arrays
2925 
2926 #define f2c( f, ff, nx, ny ) \
2927  PLFLT * *ff; \
2928  ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2929  for ( int i = 0; i < nx; i++ ) { \
2930  ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2931  for ( int j = 0; j < ny; j++ ) \
2932  *( ff[i] + j ) = *( f + nx * j + i );}
2933 
2934 // simpler plcont() for use with xform()
2935 
2936  void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2937  PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2938  {
2939  f2c( f, ff, nx, ny );
2940  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
2941  }
2942 
2943 // plcont() for use with pltr0() NOT TESTED
2944 
2945  void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2946  PLINT ly, const PLFLT *clevel, PLINT nlevel )
2947  {
2948  f2c( f, ff, nx, ny );
2949  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
2950  }
2951 
2952 // plcont() for use with pltr1()
2953 
2954  void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2955  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2956  {
2957  PLcGrid grid1;
2958  grid1.nx = nx; grid1.ny = ny;
2959  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2960  f2c( f, ff, nx, ny );
2961  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
2962  }
2963 
2964 // plcont() for use with pltr2()
2965  void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2966  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2967  {
2968  PLcGrid2 grid2;
2969  f2c( xg, xgg, nx, ny );
2970  f2c( yg, ygg, nx, ny );
2971  grid2.nx = nx; grid2.ny = ny;
2972  grid2.xg = xgg; grid2.yg = ygg;
2973  f2c( f, ff, nx, ny );
2974  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2975  }
2976 
2977 // plcont() for use with pltr2p()
2978 
2979  void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2980  PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2981  {
2982  PLcGrid2 grid2;
2983  f2c( xg, xgg, nx, ny );
2984  f2c( yg, ygg, nx, ny );
2985  grid2.nx = nx; grid2.ny = ny;
2986  grid2.xg = xgg; grid2.yg = ygg;
2987  f2c( f, ff, nx, ny );
2988  c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2989  }
2990 
2991 
2992  void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
2993  const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
2994  PLFLT *zg, int type, PLFLT data )
2995  {
2996  f2c( zg, zgg, nptsx, nptsy );
2997  plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2998  for ( int i = 0; i < nptsx; i++ )
2999  for ( int j = 0; j < nptsy; j++ )
3000  *( zg + nptsx * j + i ) = zgg[i][j];
3001  }
3002 
3003 
3004 // Plots a mesh representation of the function z[x][y].
3005 
3006  void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3007  {
3008  f2c( z, zz, nx, ny );
3009  c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3010  }
3011 
3012 // Plots a mesh representation of the function z[x][y] with contour
3013 
3014  void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3015  {
3016  f2c( z, zz, nx, ny );
3017  c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3018  }
3019 
3020 
3021 // Plots a 3-d representation of the function z[x][y].
3022  void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3023  PLINT nx, PLINT ny, PLINT opt, PLINT side )
3024  {
3025  f2c( z, zz, nx, ny );
3026  c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3027  }
3028 
3029 // Plots a 3-d representation of the function z[x][y] with contour
3030  void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3031  PLINT nx, PLINT ny, PLINT opt,
3032  const PLFLT *clevel, PLINT nlevel )
3033  {
3034  f2c( z, zz, nx, ny );
3035  c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3036  }
3037 // Plots a 3-d representation of the function z[x][y] with contour with y
3038 // index limits
3039  void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3040  PLINT nx, PLINT ny, PLINT opt,
3041  const PLFLT * clevel, PLINT nlevel,
3042  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3043  {
3044  f2c( z, zz, nx, ny );
3045  c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3046  indexxmin, indexxmax, indexymin, indexymax );
3047  }
3048 
3049 
3050  void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3051  PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3052  {
3053  f2c( z, zz, nx, ny );
3054  c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3055  }
3056 
3057  void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3058  PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3059  PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3060  {
3061  f2c( z, zz, nx, ny );
3062  c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3063  indexxmin, indexxmax, indexymin, indexymax );
3064  }
3065 
3066 
3067 // The same as in plcont. I have hardcoded the first function pointer
3068 // to plfill(). The second function pointer will use the same convention
3069 // as in plcont().
3070 //
3071 
3072 // the simpler plshade()
3073  void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3074  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3075  PLFLT shade_min, PLFLT shade_max,
3076  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3077  PLINT min_color, PLINT min_width,
3078  PLINT max_color, PLINT max_width,
3079  PLINT rectangular, PLFLT *tr )
3080  {
3081  f2c( a, aa, nx, ny );
3082  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3083  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3084  min_color, min_width, max_color, max_width,
3085  plfill, rectangular, xform, tr );
3086  }
3087 
3088 // plshade() for use with pltr1
3089  void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3090  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3091  PLFLT shade_min, PLFLT shade_max,
3092  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3093  PLINT min_color, PLINT min_width,
3094  PLINT max_color, PLINT max_width,
3095  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3096  {
3097  PLcGrid grid1;
3098  grid1.nx = nx; grid1.ny = ny;
3099  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3100  f2c( a, aa, nx, ny );
3101  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3102  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3103  min_color, min_width, max_color, max_width,
3104  plfill, rectangular, pltr1, &grid1 );
3105  }
3106 
3107 // plshade() for use with pltr2
3108  void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3109  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3110  PLFLT shade_min, PLFLT shade_max,
3111  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3112  PLINT min_color, PLINT min_width,
3113  PLINT max_color, PLINT max_width,
3114  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3115  {
3116  PLcGrid2 grid2;
3117  f2c( xg, xgg, nx, ny );
3118  f2c( yg, ygg, nx, ny );
3119  grid2.nx = nx; grid2.ny = ny;
3120  grid2.xg = xgg; grid2.yg = ygg;
3121  f2c( a, aa, nx, ny );
3122  c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3123  shade_min, shade_max, sh_cmap, sh_color, sh_width,
3124  min_color, min_width, max_color, max_width,
3125  plfill, rectangular, pltr2, &grid2 );
3126  }
3127 
3128 
3129 
3130  void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3131  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3132  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3133  PLINT cont_color, PLINT cont_width,
3134  PLINT rectangular )
3135  {
3136  f2c( a, aa, nx, ny );
3137  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3138  clevel, nlevel, fill_width, cont_color, cont_width,
3139  plfill, rectangular, NULL, NULL );
3140  }
3141 
3142  void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3143  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3144  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3145  PLINT cont_color, PLINT cont_width,
3146  PLINT rectangular, PLFLT *tr )
3147  {
3148  f2c( a, aa, nx, ny );
3149  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3150  clevel, nlevel, fill_width, cont_color, cont_width,
3151  plfill, rectangular, xform, tr );
3152  }
3153 
3154  void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3155  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3156  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3157  PLINT cont_color, PLINT cont_width,
3158  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3159  {
3160  PLcGrid grid1;
3161  grid1.nx = nx; grid1.ny = ny;
3162  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3163 
3164  f2c( a, aa, nx, ny );
3165  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3166  clevel, nlevel, fill_width, cont_color, cont_width,
3167  plfill, rectangular, pltr1, &grid1 );
3168  }
3169 
3170  void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3171  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3172  const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3173  PLINT cont_color, PLINT cont_width,
3174  PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3175  {
3176  PLcGrid2 grid2;
3177  f2c( xg, xgg, nx, ny );
3178  f2c( yg, ygg, nx, ny );
3179  grid2.nx = nx; grid2.ny = ny;
3180  grid2.xg = xgg; grid2.yg = ygg;
3181  f2c( a, aa, nx, ny );
3182  c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3183  clevel, nlevel, fill_width, cont_color, cont_width,
3184  plfill, rectangular, pltr2, &grid2 );
3185  }
3186 
3187 
3188 // Plot an array of vector arrows - uses the same function pointer
3189 // convention as plcont
3190 
3191  void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3192  {
3193  f2c( u, uu, nx, ny );
3194  f2c( v, vv, nx, ny );
3195  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3196  }
3197 
3198 // plvect() for use with pltr1
3199  void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3200  {
3201  PLcGrid grid1;
3202  grid1.nx = nx; grid1.ny = ny;
3203  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3204  f2c( u, uu, nx, ny );
3205  f2c( v, vv, nx, ny );
3206  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3207  }
3208 
3209 // plvect() for use with pltr2
3210  void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3211  {
3212  PLcGrid2 grid2;
3213  f2c( xg, xgg, nx, ny );
3214  f2c( yg, ygg, nx, ny );
3215  grid2.nx = nx; grid2.ny = ny;
3216  grid2.xg = xgg; grid2.yg = ygg;
3217  f2c( u, uu, nx, ny );
3218  f2c( v, vv, nx, ny );
3219  c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3220  }
3221 
3222 
3223 // Plot an image with distortion - uses the same function pointer
3224  void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3225  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3226  PLFLT zmin, PLFLT zmax,
3227  PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3228  {
3229  f2c( a, aa, nx, ny );
3230  plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3231  }
3232 
3233 // Plot an image with distortion - uses the same function pointer
3234 // convention as plcont
3235  void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3236  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3237  PLFLT zmin, PLFLT zmax,
3238  PLFLT valuemin, PLFLT valuemax )
3239  {
3240  f2c( a, aa, nx, ny );
3241  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3242  }
3243 
3244  void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3245  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3246  PLFLT zmin, PLFLT zmax,
3247  PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3248  {
3249  f2c( a, aa, nx, ny );
3250  plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3251  }
3252 
3253 // plimagefr() for use with pltr1
3254  void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3255  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3256  PLFLT zmin, PLFLT zmax,
3257  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3258  {
3259  PLcGrid grid1;
3260  grid1.nx = nx + 1; grid1.ny = ny + 1;
3261  grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3262  f2c( a, aa, nx, ny );
3263  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3264  }
3265 
3266 // plimagefr() for use with pltr2
3267  void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3268  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3269  PLFLT zmin, PLFLT zmax,
3270  PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3271  {
3272  PLcGrid2 grid2;
3273  f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3274  f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3275  grid2.nx = nx + 1; grid2.ny = ny + 1;
3276  grid2.xg = xgg; grid2.yg = ygg;
3277  f2c( a, aa, nx, ny );
3278  c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3279  }
3280 
3281 
3282 
3283  void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3284  PLINT opt, PLINT position, PLFLT x, PLFLT y,
3285  PLFLT x_length, PLFLT y_length,
3286  PLINT bg_color, PLINT bb_color, PLINT bb_style,
3287  PLFLT low_cap_color, PLFLT high_cap_color,
3288  PLINT cont_color, PLFLT cont_width,
3289  PLINT n_labels, const PLINT *label_opts, const char **label,
3290  PLINT n_axes, const char ** axis_opts,
3291  const PLFLT *ticks, const PLINT *sub_ticks,
3292  const PLINT *n_values, const PLFLT *a )
3293  {
3294  PLINT nx, ny, i;
3295  nx = n_axes;
3296  ny = -1;
3297  for ( i = 0; i < nx; i++ )
3298  if ( n_values[i] > ny )
3299  ny = n_values[i];
3300  f2c( a, aa, nx, ny );
3301  c_plcolorbar( p_colorbar_width, p_colorbar_height,
3302  opt, position, x, y,
3303  x_length, y_length,
3304  bg_color, bb_color, bb_style,
3305  low_cap_color, high_cap_color,
3306  cont_color, cont_width,
3307  n_labels, label_opts, label,
3308  n_axes, axis_opts,
3309  ticks, sub_ticks,
3310  n_values, aa );
3311  }
3312 
3313 
3314 
3315  SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3316  {
3317  if (!ov.is_scalar_type())
3318  return SWIG_TypeError;
3319  if (ov.is_complex_scalar())
3320  return SWIG_TypeError;
3321  if (ov.is_double_type()||ov.is_single_type()) {
3322  double v=ov.double_value();
3323  if (v<0)
3324  return SWIG_OverflowError;
3325  if (v!=floor(v))
3326  return SWIG_TypeError;
3327  }
3328  if (ov.is_int8_type()||ov.is_int16_type()||
3329  ov.is_int32_type()) {
3330  long v=ov.long_value();
3331  if (v<0)
3332  return SWIG_OverflowError;
3333  }
3334  if (ov.is_int64_type()) {
3335  long long v=ov.int64_scalar_value().value();
3336  if (v<0)
3337  return SWIG_OverflowError;
3338  }
3339  if (val)
3340  *val = ov.ulong_value();
3341  return SWIG_OK;
3342  }
3343 
3344 
3345 SWIGINTERN int
3346 SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3347 {
3348  unsigned long v;
3349  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3350  if (SWIG_IsOK(res)) {
3351  if ((v > UINT_MAX)) {
3352  return SWIG_OverflowError;
3353  } else {
3354  if (val) *val = static_cast< unsigned int >(v);
3355  }
3356  }
3357  return res;
3358 }
3359 
3360 
3362  {
3363  return octave_value(value);
3364  }
3365 
3366 
3367 SWIGINTERNINLINE octave_value
3369 {
3371 }
3372 
3373 
3374 SWIGINTERN int
3375 SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3376 {
3377  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3378  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3379  if (SWIG_IsOK(res)) {
3380  /* special case of single char conversion when we don't need space for NUL */
3381  if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3382  if (csize <= size) {
3383  if (val) {
3384  if (csize) memcpy(val, cptr, csize*sizeof(char));
3385  if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3386  }
3387  if (alloc == SWIG_NEWOBJ) {
3388  delete[] cptr;
3389  res = SWIG_DelNewMask(res);
3390  }
3391  return res;
3392  }
3393  if (alloc == SWIG_NEWOBJ) delete[] cptr;
3394  }
3395  return SWIG_TypeError;
3396 }
3397 
3398 
3401 {
3402  static int init = 0;
3403  static swig_type_info* info = 0;
3404  if (!init) {
3405  info = SWIG_TypeQuery("_p_char");
3406  init = 1;
3407  }
3408  return info;
3409 }
3410 
3411 
3412 SWIGINTERNINLINE octave_value
3413 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3414 {
3415  return std::string(carray,carray+size);
3416 }
3417 
3418 
3419 SWIGINTERN size_t
3420 SWIG_strnlen(const char* s, size_t maxlen)
3421 {
3422  const char *p;
3423  for (p = s; maxlen-- && *p; p++)
3424  ;
3425  return p - s;
3426 }
3427 
3428 
3429 SWIGINTERN int
3430 SWIG_AsVal_char (octave_value obj, char *val)
3431 {
3432  int res = SWIG_AsCharArray(obj, val, 1);
3433  if (!SWIG_IsOK(res)) {
3434  long v;
3435  res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3436  if (SWIG_IsOK(res)) {
3437  if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3438  if (val) *val = static_cast< char >(v);
3439  } else {
3440  res = SWIG_OverflowError;
3441  }
3442  }
3443  }
3444  return res;
3445 }
3446 
3447 static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3448 Specify viewport in absolute coordinates\n\
3449 \n\
3450 DESCRIPTION:\n\
3451 \n\
3452  Alternate routine to plvpor for setting up the viewport. This routine\n\
3453  should be used only if the viewport is required to have a definite\n\
3454  size in millimeters. The routine plgspa is useful for finding out the\n\
3455  size of the current subpage.\n\
3456 \n\
3457  Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3458 \n\
3459  This function is used in example 10.\n\
3460 \n\
3461 \n\
3462 \n\
3463 SYNOPSIS:\n\
3464 \n\
3465 plsvpa(xmin, xmax, ymin, ymax)\n\
3466 \n\
3467 ARGUMENTS:\n\
3468 \n\
3469  xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3470  viewport from the left-hand edge of the subpage in millimeters.\n\
3471 \n\
3472  xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3473  viewport from the left-hand edge of the subpage in millimeters.\n\
3474 \n\
3475  ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3476  viewport from the bottom edge of the subpage in millimeters.\n\
3477 \n\
3478  ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3479  from the bottom edge of the subpage in millimeters.\n\
3480 ";
3481 static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3482 Write text relative to viewport boundaries in 3D plots\n\
3483 \n\
3484 DESCRIPTION:\n\
3485 \n\
3486  Writes text at a specified position relative to the viewport\n\
3487  boundaries. Text may be written inside or outside the viewport, but\n\
3488  is clipped at the subpage boundaries. The reference point of a string\n\
3489  lies along a line passing through the string at half the height of a\n\
3490  capital letter. The position of the reference point along this line\n\
3491  is determined by just, and the position of the reference point\n\
3492  relative to the viewport is set by disp and pos.\n\
3493 \n\
3494  Redacted form: plmtex3(side, disp, pos, just, text)\n\
3495 \n\
3496  This function is used in example 28.\n\
3497 \n\
3498 \n\
3499 \n\
3500 SYNOPSIS:\n\
3501 \n\
3502 plmtex3(side, disp, pos, just, text)\n\
3503 \n\
3504 ARGUMENTS:\n\
3505 \n\
3506  side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3507  the side of the viewport along which the text is to be written.\n\
3508  The string should contain one or more of the following characters:\n\
3509  [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3510  only label the X axis, not both the X and Y axes. x: Label the X\n\
3511  axis.\n\
3512  y: Label the Y axis.\n\
3513  z: Label the Z axis.\n\
3514  p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3515  For X it is the axis that starts at y-min. For Y it is the\n\
3516  axis that starts at x-min.\n\
3517  s: Label the secondary axis.\n\
3518  v: Draw the text perpendicular to the axis.\n\
3519 \n\
3520 \n\
3521  disp (PLFLT, input) : Position of the reference point of string,\n\
3522  measured outwards from the specified viewport edge in units of the\n\
3523  current character height. Use negative disp to write within the\n\
3524  viewport.\n\
3525 \n\
3526  pos (PLFLT, input) : Position of the reference point of string\n\
3527  along the specified edge, expressed as a fraction of the length of\n\
3528  the edge.\n\
3529 \n\
3530  just (PLFLT, input) : Specifies the position of the string relative\n\
3531  to its reference point. If just=0. , the reference point is at\n\
3532  the left and if just=1. , it is at the right of the string. Other\n\
3533  values of just give intermediate justifications.\n\
3534 \n\
3535  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3536  written out.\n\
3537 ";
3538 static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3539 Set semitransparent cmap1 RGBA colors.\n\
3540 \n\
3541 DESCRIPTION:\n\
3542 \n\
3543  Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3544  RGBA vector values. This function also sets the number of cmap1\n\
3545  colors. N.B. Continuous cmap1 colors are indexed with a\n\
3546  floating-point index in the range from 0.0-1.0 which is linearly\n\
3547  transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3548  vectors in the range from 0 to\n\
3549  ncol1-1. So in order for this continuous color model to work\n\
3550  properly, it is the responsibility of the user of plscmap1 to insure\n\
3551  that these RGBA vectors are continuous functions of their integer\n\
3552  indices.\n\
3553 \n\
3554  Redacted form: plscmap1a(r, g, b, alpha)\n\
3555 \n\
3556  This function is used in example 31.\n\
3557 \n\
3558 \n\
3559 \n\
3560 SYNOPSIS:\n\
3561 \n\
3562 plscmap1a(r, g, b, alpha, ncol1)\n\
3563 \n\
3564 ARGUMENTS:\n\
3565 \n\
3566  r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3567  8-bit integers in the range from 0-255) the degree of red in the\n\
3568  color as a continuous function of the integer index of the vector.\n\
3569 \n\
3570  g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3571  8-bit integers in the range from 0-255) the degree of green in the\n\
3572  color as a continuous function of the integer index of the vector.\n\
3573 \n\
3574  b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3575  8-bit integers in the range from 0-255) the degree of blue in the\n\
3576  color as a continuous function of the integer index of the vector.\n\
3577 \n\
3578  alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3579  values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3580  completely transparent and 1.0 corresponds to completely opaque)\n\
3581  the alpha transparency of the color as a continuous function of\n\
3582  the integer index of the vector.\n\
3583 \n\
3584  ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3585  vectors.\n\
3586 ";
3587 static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3588 Select standard viewport\n\
3589 \n\
3590 DESCRIPTION:\n\
3591 \n\
3592  Selects the largest viewport within the subpage that leaves a standard\n\
3593  margin (left-hand margin of eight character heights, and a margin\n\
3594  around the other three sides of five character heights).\n\
3595 \n\
3596  Redacted form: plvsta()\n\
3597 \n\
3598  This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3599 \n\
3600 \n\
3601 \n\
3602 SYNOPSIS:\n\
3603 \n\
3604 plvsta()\n\
3605 ";
3606 static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3607 Switch to graphics screen\n\
3608 \n\
3609 DESCRIPTION:\n\
3610 \n\
3611  Sets an interactive device to graphics mode, used in conjunction with\n\
3612  pltext to allow graphics and text to be interspersed. On a device\n\
3613  which supports separate text and graphics windows, this command causes\n\
3614  control to be switched to the graphics window. If already in graphics\n\
3615  mode, this command is ignored. It is also ignored on devices which\n\
3616  only support a single window or use a different method for shifting\n\
3617  focus. See also pltext.\n\
3618 \n\
3619  Redacted form: plgra()\n\
3620 \n\
3621  This function is used in example 1.\n\
3622 \n\
3623 \n\
3624 \n\
3625 SYNOPSIS:\n\
3626 \n\
3627 plgra()\n\
3628 ";
3629 static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3630 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3631 \n\
3632 DESCRIPTION:\n\
3633 \n\
3634  Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3635  (see the PLplot documentation) index. Overwrites the previous color\n\
3636  value for the given index and, thus, does not result in any additional\n\
3637  allocation of space for colors.\n\
3638 \n\
3639  This function is used in example 30.\n\
3640 \n\
3641 \n\
3642 \n\
3643 SYNOPSIS:\n\
3644 \n\
3645 plscol0a(icol0, r, g, b, alpha)\n\
3646 \n\
3647 ARGUMENTS:\n\
3648 \n\
3649  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3650  number of colors (which is set by default, by plscmap0n, or even\n\
3651  by plscmap0).\n\
3652 \n\
3653  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3654  degree of red in the color.\n\
3655 \n\
3656  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3657  degree of green in the color.\n\
3658 \n\
3659  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3660  degree of blue in the color.\n\
3661 \n\
3662  alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3663  (0.0-1.0).\n\
3664 ";
3665 static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3666 Set y axis parameters\n\
3667 \n\
3668 DESCRIPTION:\n\
3669 \n\
3670  Identical to plsxax, except that arguments are flags for y axis. See\n\
3671  the description of plsxax for more detail.\n\
3672 \n\
3673  Redacted form: plsyax(digmax, digits)\n\
3674 \n\
3675  This function is used in examples 1, 14, and 31.\n\
3676 \n\
3677 \n\
3678 \n\
3679 SYNOPSIS:\n\
3680 \n\
3681 plsyax(digmax, digits)\n\
3682 \n\
3683 ARGUMENTS:\n\
3684 \n\
3685  digmax (PLINT, input) : Variable to set the maximum number of\n\
3686  digits for the y axis. If nonzero, the printed label will be\n\
3687  switched to a floating-point representation when the number of\n\
3688  digits exceeds digmax.\n\
3689 \n\
3690  digits (PLINT, input) : Field digits value. Currently, changing\n\
3691  its value here has no effect since it is set only by plbox or\n\
3692  plbox3. However, the user may obtain its value after a call to\n\
3693  either of these functions by calling plgyax.\n\
3694 ";
3695 static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3696 Returns 8-bit RGB values for given color index from cmap0\n\
3697 \n\
3698 DESCRIPTION:\n\
3699 \n\
3700  Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3701  PLplot documentation). Values are negative if an invalid color id is\n\
3702  given.\n\
3703 \n\
3704  Redacted form: plgcol0(icol0, r, g, b)\n\
3705 \n\
3706  This function is used in example 2.\n\
3707 \n\
3708 \n\
3709 \n\
3710 SYNOPSIS:\n\
3711 \n\
3712 plgcol0(icol0, r, g, b)\n\
3713 \n\
3714 ARGUMENTS:\n\
3715 \n\
3716  icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3717 \n\
3718  r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3719  value.\n\
3720 \n\
3721  g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3722  value.\n\
3723 \n\
3724  b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3725  value.\n\
3726 ";
3727 static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3728 Set seed for internal random number generator.\n\
3729 \n\
3730 DESCRIPTION:\n\
3731 \n\
3732  Set the seed for the internal random number generator. See plrandd for\n\
3733  further details.\n\
3734 \n\
3735  Redacted form: plseed(seed)\n\
3736 \n\
3737  This function is used in example 21.\n\
3738 \n\
3739 \n\
3740 \n\
3741 SYNOPSIS:\n\
3742 \n\
3743 plseed(seed)\n\
3744 \n\
3745 ARGUMENTS:\n\
3746 \n\
3747  seed (unsigned int, input) : Seed for random number generator.\n\
3748 ";
3749 static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
3750 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3751 \n\
3752 DESCRIPTION:\n\
3753 \n\
3754  When the implementation is completed this variant of plot3dc (see that\n\
3755  function\'s documentation for more details) should be suitable for the\n\
3756  case where the area of the x, y coordinate grid where z is defined can\n\
3757  be non-rectangular. The implementation is incomplete so the last 4\n\
3758  parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3759  indexymax; are currently ignored and the functionality is otherwise\n\
3760  identical to that of plot3dc.\n\
3761 \n\
3762  Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3763  indexymin, indexymax)\n\
3764 \n\
3765 \n\
3766  This function is not used in any example.\n\
3767 \n\
3768 \n\
3769 \n\
3770 SYNOPSIS:\n\
3771 \n\
3772 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3773 \n\
3774 ARGUMENTS:\n\
3775 \n\
3776  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3777  which the function is evaluated.\n\
3778 \n\
3779  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3780  which the function is evaluated.\n\
3781 \n\
3782  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3783  plot. Should have dimensions of\n\
3784  nx by\n\
3785  ny.\n\
3786 \n\
3787  nx (PLINT, input) : Number of x values at which the function is\n\
3788  evaluated.\n\
3789 \n\
3790  ny (PLINT, input) : Number of y values at which the function is\n\
3791  evaluated.\n\
3792 \n\
3793  opt (PLINT, input) : Determines the way in which the surface is\n\
3794  represented. To specify more than one option just add the options,\n\
3795  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3796  showing z as a function of x for each value of y[j] .\n\
3797  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3798  for each value of x[i] .\n\
3799  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3800  at which function is defined.\n\
3801  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3802  the z value being plotted. The color is used from the current\n\
3803  cmap1.\n\
3804  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3805  using parameters\n\
3806  nlevel and\n\
3807  clevel.\n\
3808  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3809  the borders of the plotted function.\n\
3810 \n\
3811 \n\
3812  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3813  levels.\n\
3814 \n\
3815  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3816 \n\
3817  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3818  corresponds to the first x index where z is defined.\n\
3819 \n\
3820  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3821  which corresponds (by convention) to one more than the last x\n\
3822  index value where z is defined.\n\
3823 \n\
3824  indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3825  values which all must be ≥ 0. These values are the first y index\n\
3826  where z is defined for a particular x index in the range from\n\
3827  indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3828  indexxmax.\n\
3829 \n\
3830  indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3831  values which all must be ≤ ny. These values correspond (by\n\
3832  convention) to one more than the last y index where z is defined\n\
3833  for a particular x index in the range from indexxmin to indexxmax\n\
3834  - 1. The dimension of indexymax is indexxmax.\n\
3835 ";
3836 static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3837 Get output file name\n\
3838 \n\
3839 DESCRIPTION:\n\
3840 \n\
3841  Gets the current output file name, if applicable.\n\
3842 \n\
3843  Redacted form: plgfnam(fnam)\n\
3844 \n\
3845  This function is used in example 31.\n\
3846 \n\
3847 \n\
3848 \n\
3849 SYNOPSIS:\n\
3850 \n\
3851 plgfnam(fnam)\n\
3852 \n\
3853 ARGUMENTS:\n\
3854 \n\
3855  fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3856  (with preallocated length of 80 characters or more) containing the\n\
3857  file name.\n\
3858 ";
3859 static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3860 Specify window\n\
3861 \n\
3862 DESCRIPTION:\n\
3863 \n\
3864  Specify the window, i.e., the world coordinates of the edges of the\n\
3865  viewport.\n\
3866 \n\
3867  Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3868 \n\
3869  This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3870  29, and 31.\n\
3871 \n\
3872 \n\
3873 \n\
3874 SYNOPSIS:\n\
3875 \n\
3876 plwind(xmin, xmax, ymin, ymax)\n\
3877 \n\
3878 ARGUMENTS:\n\
3879 \n\
3880  xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3881  of the viewport.\n\
3882 \n\
3883  xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3884  of the viewport.\n\
3885 \n\
3886  ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3887  the viewport.\n\
3888 \n\
3889  ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3890  viewport.\n\
3891 ";
3892 static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
3893 Set cmap1 colors using a piece-wise linear relationship\n\
3894 \n\
3895 DESCRIPTION:\n\
3896 \n\
3897  Set cmap1 colors using a piece-wise linear relationship between the\n\
3898  cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
3899  (see the PLplot documentation). May be called at any time.\n\
3900 \n\
3901  The idea here is to specify a number of control points that define the\n\
3902  mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
3903  these points, linear interpolation is used which gives a smooth\n\
3904  variation of color with intensity index. Any number of control points\n\
3905  may be specified, located at arbitrary positions, although typically 2\n\
3906  - 4 are enough. Another way of stating this is that we are traversing\n\
3907  a given number of lines through HLS or RGB space as we move through\n\
3908  cmap1 intensity indices. The control points at the minimum and\n\
3909  maximum position (0 and 1) must always be specified. By adding more\n\
3910  control points you can get more variation. One good technique for\n\
3911  plotting functions that vary about some expected average is to use an\n\
3912  additional 2 control points in the center (position ~= 0.5) that are\n\
3913  the same lightness as the background (typically white for paper\n\
3914  output, black for crt), and same hue as the boundary control points.\n\
3915  This allows the highs and lows to be very easily distinguished.\n\
3916 \n\
3917  Each control point must specify the cmap1 intensity index and the\n\
3918  associated three coordinates in HLS or RGB space. The first point\n\
3919  must correspond to position = 0, and the last to position = 1.\n\
3920 \n\
3921  If RGB colors are provided then the interpolation takes place in RGB\n\
3922  space and is trivial. However if HLS colors are provided then, because\n\
3923  of the circular nature of the color wheel for the hue coordinate, the\n\
3924  interpolation could be performed in either direction around the color\n\
3925  wheel. The default behaviour is for the hue to be linearly\n\
3926  interpolated ignoring this circular property of hue. So for example,\n\
3927  the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
3928  green and cyan. If instead you wish to interpolate the other way\n\
3929  around the color wheel you have two options. You may provide hues\n\
3930  outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
3931  for red the interpolation will proceed via magenta. Alternatively you\n\
3932  can utilise the alt_hue_path variable to reverse the direction of\n\
3933  interpolation if you need to provide hues within the [0-360) range.\n\
3934 \n\
3935  Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3936  240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3937  -120]falsegreen-yellow-red-magenta-blue[240\n\
3938  480]falseblue-magenta-red-yellow-green[120\n\
3939  240]truegreen-yellow-red-magenta-blue[240\n\
3940  120]trueblue-magenta-red-yellow-green\n\
3941 \n\
3942  Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3943  1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3944  1]magnitudeHLSsaturation[0, 1]magnitude\n\
3945 \n\
3946  Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
3947  alt_hue_path)\n\
3948 \n\
3949  This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
3950 \n\
3951 \n\
3952 \n\
3953 SYNOPSIS:\n\
3954 \n\
3955 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
3956 \n\
3957 ARGUMENTS:\n\
3958 \n\
3959  itype (PLBOOL, input) : true: RGB, false: HLS.\n\
3960 \n\
3961  npts (PLINT, input) : number of control points\n\
3962 \n\
3963  intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
3964  intensity index (0.0-1.0) in ascending order for each control\n\
3965  point.\n\
3966 \n\
3967  coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
3968  coordinate (H or R) for each control point.\n\
3969 \n\
3970  coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
3971  coordinate (L or G) for each control point.\n\
3972 \n\
3973  coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
3974  coordinate (S or B) for each control point.\n\
3975 \n\
3976  alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
3977  npts - 1 elements), each containing either true to use the reversed\n\
3978  HLS interpolation or false to use the regular HLS interpolation.\n\
3979  (alt_hue_path[i] refers to the interpolation interval between the\n\
3980  i and i + 1 control points). This parameter is not used for RGB\n\
3981  colors (\n\
3982  itype = true).\n\
3983 ";
3984 static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
3985 Set the pause (on end-of-page) status\n\
3986 \n\
3987 DESCRIPTION:\n\
3988 \n\
3989  Set the pause (on end-of-page) status.\n\
3990 \n\
3991  Redacted form: plspause(pause)\n\
3992 \n\
3993  This function is in examples 14,20.\n\
3994 \n\
3995 \n\
3996 \n\
3997 SYNOPSIS:\n\
3998 \n\
3999 plspause(pause)\n\
4000 \n\
4001 ARGUMENTS:\n\
4002 \n\
4003  pause (PLBOOL, input) : If pause is true there will be a pause on\n\
4004  end-of-page for those drivers which support this. Otherwise there\n\
4005  is no pause.\n\
4006 ";
4007 static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
4008 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
4009 \n\
4010 DESCRIPTION:\n\
4011 \n\
4012  Routine for creating a discrete plot legend with a plotted filled box,\n\
4013  line, and/or line of symbols for each annotated legend entry. (See\n\
4014  plcolorbar for similar functionality for creating continuous color\n\
4015  bars.) The arguments of pllegend provide control over the location\n\
4016  and size of the legend as well as the location and characteristics of\n\
4017  the elements (most of which are optional) within that legend. The\n\
4018  resulting legend is clipped at the boundaries of the current subpage.\n\
4019  (N.B. the adopted coordinate system used for some of the parameters is\n\
4020  defined in the documentation of the position parameter.)\n\
4021 \n\
4022  Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
4023  position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
4024  ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
4025  test_justification, text_colors, text, box_colors, box_patterns,\n\
4026  box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
4027  symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
4028 \n\
4029  This function is used in examples 4, 26, and 33.\n\
4030 \n\
4031 \n\
4032 \n\
4033 SYNOPSIS:\n\
4034 \n\
4035 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\
4036 \n\
4037 ARGUMENTS:\n\
4038 \n\
4039  p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4040  legend width in adopted coordinates. This quantity is calculated\n\
4041  from plot_width, text_offset, ncolumn (possibly modified inside\n\
4042  the routine depending on nlegend and nrow), and the length\n\
4043  (calculated internally) of the longest text string.\n\
4044 \n\
4045  p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4046  legend height in adopted coordinates. This quantity is calculated\n\
4047  from text_scale, text_spacing, and nrow (possibly modified inside\n\
4048  the routine depending on nlegend and nrow).\n\
4049 \n\
4050  opt (PLINT, input) : opt contains bits controlling the overall\n\
4051  legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
4052  on the left of the legend and the plotted area on the right.\n\
4053  Otherwise, put the text area on the right of the legend and the\n\
4054  plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
4055  plot a (semitransparent) background for the legend. If the\n\
4056  PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
4057  legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
4058  possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
4059  plot the resulting array of legend entries in row-major order.\n\
4060  Otherwise, plot the legend entries in column-major order.\n\
4061 \n\
4062  position (PLINT, input) : position contains bits which control the\n\
4063  overall position of the legend and the definition of the adopted\n\
4064  coordinates used for positions just like what is done for the\n\
4065  position argument for plcolorbar. However, note that the defaults\n\
4066  for the position bits (see below) are different than the\n\
4067  plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
4068  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
4069  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
4070  the 16 possible standard positions (the 4 corners and centers of\n\
4071  the 4 sides for both the inside and outside cases) of the legend\n\
4072  relative to the adopted coordinate system. The corner positions\n\
4073  are specified by the appropriate combination of two of the\n\
4074  PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
4075  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
4076  value of one of those bits. The adopted coordinates are\n\
4077  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
4078  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
4079  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
4080  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
4081  then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
4082  If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
4083  use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
4084  PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
4085 \n\
4086  x (PLFLT, input) : X offset of the legend position in adopted\n\
4087  coordinates from the specified standard position of the legend.\n\
4088  For positive x, the direction of motion away from the standard\n\
4089  position is inward/outward from the standard corner positions or\n\
4090  standard left or right positions if the\n\
4091  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
4092  For the standard top or bottom positions, the direction of motion\n\
4093  is toward positive X.\n\
4094 \n\
4095  y (PLFLT, input) : Y offset of the legend position in adopted\n\
4096  coordinates from the specified standard position of the legend.\n\
4097  For positive y, the direction of motion away from the standard\n\
4098  position is inward/outward from the standard corner positions or\n\
4099  standard top or bottom positions if the\n\
4100  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
4101  the standard left or right positions, the direction of motion is\n\
4102  toward positive Y.\n\
4103 \n\
4104  plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
4105  of the plot area (where the colored boxes, lines, and/or lines of\n\
4106  symbols are drawn) of the legend.\n\
4107 \n\
4108  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
4109  legend (PL_LEGEND_BACKGROUND).\n\
4110 \n\
4111  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
4112  for the legend (PL_LEGEND_BOUNDING_BOX).\n\
4113 \n\
4114  bb_style (PLINT, input) : The pllsty style number for the\n\
4115  bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
4116 \n\
4117  nrow (PLINT, input) : The number of rows in the matrix used to\n\
4118  render the\n\
4119  nlegend legend entries. For internal transformations of\n\
4120  nrow, see further remarks under\n\
4121  nlegend.\n\
4122 \n\
4123  ncolumn (PLINT, input) : The number of columns in the matrix used\n\
4124  to render the\n\
4125  nlegend legend entries. For internal transformations of\n\
4126  ncolumn, see further remarks under\n\
4127  nlegend.\n\
4128 \n\
4129  nlegend (PLINT, input) : Number of legend entries. The above\n\
4130  nrow and\n\
4131  ncolumn values are transformed internally to be consistent with\n\
4132  nlegend. If either\n\
4133  nrow or\n\
4134  ncolumn is non-positive it is replaced by 1. If the resulting product\n\
4135  of\n\
4136  nrow and\n\
4137  ncolumn is less than\n\
4138  nlegend, the smaller of the two (or\n\
4139  nrow, if\n\
4140  nrow ==\n\
4141  ncolumn) is increased so the product is >=\n\
4142  nlegend. Thus, for example, the common\n\
4143  nrow = 0,\n\
4144  ncolumn = 0 case is transformed internally to\n\
4145  nrow =\n\
4146  nlegend,\n\
4147  ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
4148  column.\n\
4149 \n\
4150  opt_array (PLINT_VECTOR, input) : A vector of\n\
4151  nlegend values of options to control each individual plotted area\n\
4152  corresponding to a legend entry. If the\n\
4153  PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
4154  area. If the\n\
4155  PL_LEGEND_COLOR_BOX,\n\
4156  PL_LEGEND_LINE, and/or\n\
4157  PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
4158  entry is plotted with a colored box; a line; and/or a line of\n\
4159  symbols.\n\
4160 \n\
4161  text_offset (PLFLT, input) : Offset of the text area from the plot\n\
4162  area in units of character width.\n\
4163 \n\
4164  text_scale (PLFLT, input) : Character height scale for text\n\
4165  annotations.\n\
4166 \n\
4167  text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
4168  character height from one legend entry to the next.\n\
4169 \n\
4170  text_justification (PLFLT, input) : Justification parameter used\n\
4171  for text justification. The most common values of\n\
4172  text_justification are 0., 0.5, or 1. corresponding to a text that\n\
4173  is left justified, centred, or right justified within the text\n\
4174  area, but other values are allowed as well.\n\
4175 \n\
4176  text_colors (PLINT_VECTOR, input) : A vector containing\n\
4177  nlegend cmap0 text colors.\n\
4178 \n\
4179  text (PLCHAR_MATRIX, input) : A vector of\n\
4180  nlegend UTF-8 character strings containing the legend annotations.\n\
4181 \n\
4182  box_colors (PLINT_VECTOR, input) : A vector containing\n\
4183  nlegend cmap0 colors for the discrete colored boxes (\n\
4184  PL_LEGEND_COLOR_BOX).\n\
4185 \n\
4186  box_patterns (PLINT_VECTOR, input) : A vector containing\n\
4187  nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
4188  PL_LEGEND_COLOR_BOX).\n\
4189 \n\
4190  box_scales (PLFLT_VECTOR, input) : A vector containing\n\
4191  nlegend scales (units of fraction of character height) for the height\n\
4192  of the discrete colored boxes (\n\
4193  PL_LEGEND_COLOR_BOX).\n\
4194 \n\
4195  box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4196  nlegend line widths for the patterns specified by box_patterns (\n\
4197  PL_LEGEND_COLOR_BOX).\n\
4198 \n\
4199  line_colors (PLINT_VECTOR, input) : A vector containing\n\
4200  nlegend cmap0 line colors (\n\
4201  PL_LEGEND_LINE).\n\
4202 \n\
4203  line_styles (PLINT_VECTOR, input) : A vector containing\n\
4204  nlegend line styles (plsty indices) (\n\
4205  PL_LEGEND_LINE).\n\
4206 \n\
4207  line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4208  nlegend line widths (\n\
4209  PL_LEGEND_LINE).\n\
4210 \n\
4211  symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
4212  nlegend cmap0 symbol colors (\n\
4213  PL_LEGEND_SYMBOL).\n\
4214 \n\
4215  symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
4216  nlegend scale values for the symbol height (\n\
4217  PL_LEGEND_SYMBOL).\n\
4218 \n\
4219  symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
4220  nlegend numbers of symbols to be drawn across the width of the plotted\n\
4221  area (\n\
4222  PL_LEGEND_SYMBOL).\n\
4223 \n\
4224  symbols (PLCHAR_MATRIX, input) : A vector of\n\
4225  nlegend UTF-8 character strings containing the legend symbols. (\n\
4226  PL_LEGEND_SYMBOL).\n\
4227 ";
4228 static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
4229 Set number of colors in cmap1\n\
4230 \n\
4231 DESCRIPTION:\n\
4232 \n\
4233  Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
4234  values if this is the first allocation (see the PLplot documentation).\n\
4235 \n\
4236  Redacted form: plscmap1n(ncol1)\n\
4237 \n\
4238  This function is used in examples 8, 11, 20, and 21.\n\
4239 \n\
4240 \n\
4241 \n\
4242 SYNOPSIS:\n\
4243 \n\
4244 plscmap1n(ncol1)\n\
4245 \n\
4246 ARGUMENTS:\n\
4247 \n\
4248  ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
4249  the cmap1 palette. If this number is zero or less, then the value\n\
4250  from the previous call to plscmap1n is used and if there is no\n\
4251  previous call, then a default value is used.\n\
4252 ";
4253 static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
4254 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
4255 \n\
4256 DESCRIPTION:\n\
4257 \n\
4258  Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
4259  (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
4260  Values are negative if an invalid color id is given.\n\
4261 \n\
4262  Redacted form: plgcola(r, g, b)\n\
4263 \n\
4264  This function is used in example 30.\n\
4265 \n\
4266 \n\
4267 \n\
4268 SYNOPSIS:\n\
4269 \n\
4270 plgcol0a(icol0, r, g, b, alpha)\n\
4271 \n\
4272 ARGUMENTS:\n\
4273 \n\
4274  icol0 (PLINT, input) : Index of desired cmap0 color.\n\
4275 \n\
4276  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
4277  in the range from 0 to 255.\n\
4278 \n\
4279  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
4280  in the range from 0 to 255.\n\
4281 \n\
4282  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
4283  in the range from 0 to 255.\n\
4284 \n\
4285  alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
4286  transparency in the range from (0.0-1.0).\n\
4287 ";
4288 static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
4289 Replays contents of plot buffer to current device/file\n\
4290 \n\
4291 DESCRIPTION:\n\
4292 \n\
4293  Replays contents of plot buffer to current device/file.\n\
4294 \n\
4295  Redacted form: plreplot()\n\
4296 \n\
4297  This function is used in example 1,20.\n\
4298 \n\
4299 \n\
4300 \n\
4301 SYNOPSIS:\n\
4302 \n\
4303 plreplot()\n\
4304 ";
4305 static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
4306 Simple routine to write labels\n\
4307 \n\
4308 DESCRIPTION:\n\
4309 \n\
4310  Routine for writing simple labels. Use plmtex for more complex labels.\n\
4311 \n\
4312  Redacted form: pllab(xlabel, ylabel, tlabel)\n\
4313 \n\
4314  This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
4315 \n\
4316 \n\
4317 \n\
4318 SYNOPSIS:\n\
4319 \n\
4320 pllab(xlabel, ylabel, tlabel)\n\
4321 \n\
4322 ARGUMENTS:\n\
4323 \n\
4324  xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4325  the label for the x axis.\n\
4326 \n\
4327  ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4328  the label for the y axis.\n\
4329 \n\
4330  tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4331  the title of the plot.\n\
4332 ";
4333 static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
4334 Set parameters that define current device-space window\n\
4335 \n\
4336 DESCRIPTION:\n\
4337 \n\
4338  Set relative margin width, aspect ratio, and relative justification\n\
4339  that define current device-space window. If you want to just use the\n\
4340  previous value for any of these, just pass in the magic value\n\
4341  PL_NOTSET. It is unlikely that one should ever need to change the\n\
4342  aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4343  called the default values of mar, jx, and jy are all 0. aspect is set\n\
4344  to a device-specific value.\n\
4345 \n\
4346  Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4347 \n\
4348  This function is used in example 31.\n\
4349 \n\
4350 \n\
4351 \n\
4352 SYNOPSIS:\n\
4353 \n\
4354 plsdidev(mar, aspect, jx, jy)\n\
4355 \n\
4356 ARGUMENTS:\n\
4357 \n\
4358  mar (PLFLT, input) : Relative margin width.\n\
4359 \n\
4360  aspect (PLFLT, input) : Aspect ratio.\n\
4361 \n\
4362  jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4363  the range -0.5 to 0.5.\n\
4364 \n\
4365  jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4366  the range -0.5 to 0.5.\n\
4367 ";
4368 static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
4369 Begin a new page\n\
4370 \n\
4371 DESCRIPTION:\n\
4372 \n\
4373  Begins a new page. For a file driver, the output file is opened if\n\
4374  necessary. Advancing the page via pleop and plbop is useful when a\n\
4375  page break is desired at a particular point when plotting to subpages.\n\
4376  Another use for pleop and plbop is when plotting pages to different\n\
4377  files, since you can manually set the file name by calling plsfnam\n\
4378  after the call to pleop. (In fact some drivers may only support a\n\
4379  single page per file, making this a necessity.) One way to handle\n\
4380  this case automatically is to page advance via pladv, but enable\n\
4381  familying (see plsfam) with a small limit on the file size so that a\n\
4382  new family member file will be created on each page break.\n\
4383 \n\
4384  Redacted form: plbop()\n\
4385 \n\
4386  This function is used in examples 2 and 20.\n\
4387 \n\
4388 \n\
4389 \n\
4390 SYNOPSIS:\n\
4391 \n\
4392 plbop()\n\
4393 ";
4394 static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
4395 Set cmap0 colors by 8-bit RGB values\n\
4396 \n\
4397 DESCRIPTION:\n\
4398 \n\
4399  Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4400  documentation). This sets the entire color map -- only as many colors\n\
4401  as specified will be allocated.\n\
4402 \n\
4403  Redacted form: plscmap0(r, g, b)\n\
4404 \n\
4405  This function is used in examples 2 and 24.\n\
4406 \n\
4407 \n\
4408 \n\
4409 SYNOPSIS:\n\
4410 \n\
4411 plscmap0(r, g, b, ncol0)\n\
4412 \n\
4413 ARGUMENTS:\n\
4414 \n\
4415  r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4416  integers (0-255) representing the degree of red in the color.\n\
4417 \n\
4418  g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4419  integers (0-255) representing the degree of green in the color.\n\
4420 \n\
4421  b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4422  integers (0-255) representing the degree of blue in the color.\n\
4423 \n\
4424  ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4425 ";
4426 static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
4427 Set the number of subpages in x and y\n\
4428 \n\
4429 DESCRIPTION:\n\
4430 \n\
4431  Set the number of subpages in x and y.\n\
4432 \n\
4433  Redacted form: plssub(nx, ny)\n\
4434 \n\
4435  This function is examples 1,2,14,21,25,27.\n\
4436 \n\
4437 \n\
4438 \n\
4439 SYNOPSIS:\n\
4440 \n\
4441 plssub(nx, ny)\n\
4442 \n\
4443 ARGUMENTS:\n\
4444 \n\
4445  nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4446  of window columns).\n\
4447 \n\
4448  ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4449  of window rows).\n\
4450 ";
4451 static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
4452 Set a global coordinate transform function\n\
4453 \n\
4454 DESCRIPTION:\n\
4455 \n\
4456  This function can be used to define a coordinate transformation which\n\
4457  affects all elements drawn within the current plot window. The\n\
4458  coordinate_transform callback function is similar to that provided for\n\
4459  the plmap and plmeridians functions. The coordinate_transform_data\n\
4460  parameter may be used to pass extra data to coordinate_transform.\n\
4461 \n\
4462  Redacted form: General: plstransform(coordinate_transform,\n\
4463  coordinate_transform_data)\n\
4464 \n\
4465 \n\
4466  This function is used in examples 19 and 22.\n\
4467 \n\
4468 \n\
4469 \n\
4470 SYNOPSIS:\n\
4471 \n\
4472 plstransform(coordinate_transform, coordinate_transform_data)\n\
4473 \n\
4474 ARGUMENTS:\n\
4475 \n\
4476  coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4477  function that defines the transformation from the input (x, y)\n\
4478  world coordinates to new PLplot world coordinates. If\n\
4479  coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4480  case), then no transform is applied.\n\
4481 \n\
4482  coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4483  for\n\
4484  coordinate_transform.\n\
4485 ";
4486 static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
4487 Set opaque RGB cmap1 colors values\n\
4488 \n\
4489 DESCRIPTION:\n\
4490 \n\
4491  Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4492  vector values. This function also sets the number of cmap1 colors.\n\
4493  N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4494  in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4495  plcol1) to an integer index of these RGB vectors in the range from 0\n\
4496  to\n\
4497  ncol1-1. So in order for this continuous color model to work\n\
4498  properly, it is the responsibility of the user of plscmap1 to insure\n\
4499  that these RGB vectors are continuous functions of their integer\n\
4500  indices.\n\
4501 \n\
4502  Redacted form: plscmap1(r, g, b)\n\
4503 \n\
4504  This function is used in example 31.\n\
4505 \n\
4506 \n\
4507 \n\
4508 SYNOPSIS:\n\
4509 \n\
4510 plscmap1(r, g, b, ncol1)\n\
4511 \n\
4512 ARGUMENTS:\n\
4513 \n\
4514  r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4515  8-bit integers in the range from 0-255) the degree of red in the\n\
4516  color as a continuous function of the integer index of the vector.\n\
4517 \n\
4518  g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4519  8-bit integers in the range from 0-255) the degree of green in the\n\
4520  color as a continuous function of the integer index of the vector.\n\
4521 \n\
4522  b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4523  8-bit integers in the range from 0-255) the degree of blue in the\n\
4524  color as a continuous function of the integer index of the vector.\n\
4525 \n\
4526  ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4527 ";
4528 static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
4529 Configure the transformation between continuous and broken-down time for the current stream\n\
4530 \n\
4531 DESCRIPTION:\n\
4532 \n\
4533  Configure the transformation between continuous and broken-down time\n\
4534  for the current stream. This transformation is used by both plbtime\n\
4535  and plctime.\n\
4536 \n\
4537  Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4538  ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4539 \n\
4540 \n\
4541  This function is used in example 29.\n\
4542 \n\
4543 \n\
4544 \n\
4545 SYNOPSIS:\n\
4546 \n\
4547 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4548 \n\
4549 ARGUMENTS:\n\
4550 \n\
4551  scale (PLFLT, input) : The number of days per continuous time unit.\n\
4552  As a special case, if\n\
4553  scale is 0., then all other arguments are ignored, and the result (the\n\
4554  default used by PLplot) is the equivalent of a call to\n\
4555  plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4556  That is, for this special case broken-down time is calculated with\n\
4557  the proleptic Gregorian calendar with no leap seconds inserted,\n\
4558  and the continuous time is defined as the number of seconds since\n\
4559  the Unix epoch of 1970-01-01T00:00:00Z.\n\
4560 \n\
4561  offset1 (PLFLT, input) : If\n\
4562  ifbtime_offset is true, the parameters\n\
4563  offset1 and\n\
4564  offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4565  (with units in days) specify the epoch of the continuous time\n\
4566  relative to the MJD epoch corresponding to the Gregorian calendar\n\
4567  date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4568  are used to specify the origin to allow users (by specifying\n\
4569  offset1 as an integer that can be exactly represented by a\n\
4570  floating-point variable and specifying\n\
4571  offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4572  the numerical errors of the continuous time representation.\n\
4573 \n\
4574  offset2 (PLFLT, input) : See documentation of\n\
4575  offset1.\n\
4576 \n\
4577  ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4578  transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4579  calendar is used for broken-down time rather than the proleptic\n\
4580  Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4581  have been historically used to define UTC are inserted into the\n\
4582  broken-down time. Other possibilities for additional control bits\n\
4583  for ccontrol exist such as making the historical time corrections\n\
4584  in the broken-down time corresponding to ET (ephemeris time) or\n\
4585  making the (slightly non-constant) corrections from international\n\
4586  atomic time (TAI) to what astronomers define as terrestrial time\n\
4587  (TT). But those additional possibilities have not been\n\
4588  implemented yet in the qsastime library (one of the PLplot utility\n\
4589  libraries).\n\
4590 \n\
4591  ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4592  epoch of the continuous time scale is specified by the user. If\n\
4593  ifbtime_offset is false, then\n\
4594  offset1 and\n\
4595  offset2 are used to specify the epoch, and the following broken-down\n\
4596  time parameters are completely ignored. If\n\
4597  ifbtime_offset is true, then\n\
4598  offset1 and\n\
4599  offset2 are completely ignored, and the following broken-down time\n\
4600  parameters are used to specify the epoch.\n\
4601 \n\
4602  year (PLINT, input) : Year of epoch.\n\
4603 \n\
4604  month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4605  11 (December).\n\
4606 \n\
4607  day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4608 \n\
4609  hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4610 \n\
4611  min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4612 \n\
4613  sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4614 ";
4615 static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
4616 Set length of minor ticks\n\
4617 \n\
4618 DESCRIPTION:\n\
4619 \n\
4620  This sets up the length of the minor ticks and the length of the\n\
4621  terminals on error bars. The actual length is the product of the\n\
4622  default length and a scaling factor as for character height.\n\
4623 \n\
4624  Redacted form: plsmin(def, scale)\n\
4625 \n\
4626  This function is used in example 29.\n\
4627 \n\
4628 \n\
4629 \n\
4630 SYNOPSIS:\n\
4631 \n\
4632 plsmin(def, scale)\n\
4633 \n\
4634 ARGUMENTS:\n\
4635 \n\
4636  def (PLFLT, input) : The default length of a minor tick in\n\
4637  millimeters, should be set to zero if the default length is to\n\
4638  remain unchanged.\n\
4639 \n\
4640  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4641  actual tick length.\n\
4642 ";
4643 static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
4644 Set character size\n\
4645 \n\
4646 DESCRIPTION:\n\
4647 \n\
4648  This sets up the size of all subsequent characters drawn. The actual\n\
4649  height of a character is the product of the default character size and\n\
4650  a scaling factor.\n\
4651 \n\
4652  Redacted form: plschr(def, scale)\n\
4653 \n\
4654  This function is used in examples 2, 13, 23, and 24.\n\
4655 \n\
4656 \n\
4657 \n\
4658 SYNOPSIS:\n\
4659 \n\
4660 plschr(def, scale)\n\
4661 \n\
4662 ARGUMENTS:\n\
4663 \n\
4664  def (PLFLT, input) : The default height of a character in\n\
4665  millimeters, should be set to zero if the default height is to\n\
4666  remain unchanged. For rasterized drivers the dx and dy values\n\
4667  specified in plspage are used to convert from mm to pixels (note\n\
4668  the different unit systems used). This dpi aware scaling is not\n\
4669  implemented for all drivers yet.\n\
4670 \n\
4671  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4672  actual character height.\n\
4673 ";
4674 static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4675 Initialize PLplot\n\
4676 \n\
4677 DESCRIPTION:\n\
4678 \n\
4679  Initializing the plotting package. The program prompts for the device\n\
4680  keyword or number of the desired output device. Hitting a RETURN in\n\
4681  response to the prompt is the same as selecting the first device.\n\
4682  plinit will issue no prompt if either the device was specified\n\
4683  previously (via command line flag, the plsetopt function, or the\n\
4684  plsdev function), or if only one device is enabled when PLplot is\n\
4685  installed. If subpages have been specified, the output device is\n\
4686  divided into nx by ny subpages, each of which may be used\n\
4687  independently. If plinit is called again during a program, the\n\
4688  previously opened file will be closed. The subroutine pladv is used\n\
4689  to advance from one subpage to the next.\n\
4690 \n\
4691  Redacted form: plinit()\n\
4692 \n\
4693  This function is used in all of the examples.\n\
4694 \n\
4695 \n\
4696 \n\
4697 SYNOPSIS:\n\
4698 \n\
4699 plinit()\n\
4700 ";
4701 static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4702 Draw a box with axes, etc\n\
4703 \n\
4704 DESCRIPTION:\n\
4705 \n\
4706  Draws a box around the currently defined viewport, and labels it with\n\
4707  world coordinate values appropriate to the window. Thus plbox should\n\
4708  only be called after defining both viewport and window. The ascii\n\
4709  character strings xopt and yopt specify how the box should be drawn as\n\
4710  described below. If ticks and/or subticks are to be drawn for a\n\
4711  particular axis, the tick intervals and number of subintervals may be\n\
4712  specified explicitly, or they may be defaulted by setting the\n\
4713  appropriate arguments to zero.\n\
4714 \n\
4715  Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4716 \n\
4717 \n\
4718  This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4719  and 29.\n\
4720 \n\
4721 \n\
4722 \n\
4723 SYNOPSIS:\n\
4724 \n\
4725 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4726 \n\
4727 ARGUMENTS:\n\
4728 \n\
4729  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4730  options for the x axis. The string can include any combination of\n\
4731  the following letters (upper or lower case) in any order: a: Draws\n\
4732  axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4733  (x=0).\n\
4734  b: Draws bottom (X) or left (Y) edge of frame.\n\
4735  c: Draws top (X) or right (Y) edge of frame.\n\
4736  d: Plot labels as date / time. Values are assumed to be\n\
4737  seconds since the epoch (as used by gmtime).\n\
4738  f: Always use fixed point numeric labels.\n\
4739  g: Draws a grid at the major tick interval.\n\
4740  h: Draws a grid at the minor tick interval.\n\
4741  i: Inverts tick marks, so they are drawn outwards, rather than\n\
4742  inwards.\n\
4743  l: Labels axis logarithmically. This only affects the labels,\n\
4744  not the data, and so it is necessary to compute the logarithms\n\
4745  of data points before passing them to any of the drawing\n\
4746  routines.\n\
4747  m: Writes numeric labels at major tick intervals in the\n\
4748  unconventional location (above box for X, right of box for Y).\n\
4749  n: Writes numeric labels at major tick intervals in the\n\
4750  conventional location (below box for X, left of box for Y).\n\
4751  o: Use custom labelling function to generate axis label text.\n\
4752  The custom labelling function can be defined with the\n\
4753  plslabelfunc command.\n\
4754  s: Enables subticks between major ticks, only valid if t is\n\
4755  also specified.\n\
4756  t: Draws major ticks.\n\
4757  u: Exactly like \"b\" except don\'t draw edge line.\n\
4758  w: Exactly like \"c\" except don\'t draw edge line.\n\
4759  x: Exactly like \"t\" (including the side effect of the\n\
4760  numerical labels for the major ticks) except exclude drawing\n\
4761  the major and minor tick marks.\n\
4762 \n\
4763 \n\
4764  xtick (PLFLT, input) : World coordinate interval between major\n\
4765  ticks on the x axis. If it is set to zero, PLplot automatically\n\
4766  generates a suitable tick interval.\n\
4767 \n\
4768  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4769  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4770  generates a suitable minor tick interval.\n\
4771 \n\
4772  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4773  options for the y axis. The string can include any combination of\n\
4774  the letters defined above for xopt, and in addition may contain:\n\
4775  v: Write numeric labels for the y axis parallel to the base of the\n\
4776  graph, rather than parallel to the axis.\n\
4777 \n\
4778 \n\
4779  ytick (PLFLT, input) : World coordinate interval between major\n\
4780  ticks on the y axis. If it is set to zero, PLplot automatically\n\
4781  generates a suitable tick interval.\n\
4782 \n\
4783  nysub (PLINT, input) : Number of subintervals between major y axis\n\
4784  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4785  generates a suitable minor tick interval.\n\
4786 ";
4787 static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4788 Get parameters that define current device-space window\n\
4789 \n\
4790 DESCRIPTION:\n\
4791 \n\
4792  Get relative margin width, aspect ratio, and relative justification\n\
4793  that define current device-space window. If plsdidev has not been\n\
4794  called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4795  p_jy will all be 0.\n\
4796 \n\
4797  Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4798 \n\
4799  This function is used in example 31.\n\
4800 \n\
4801 \n\
4802 \n\
4803 SYNOPSIS:\n\
4804 \n\
4805 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4806 \n\
4807 ARGUMENTS:\n\
4808 \n\
4809  p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4810  margin width.\n\
4811 \n\
4812  p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4813  ratio.\n\
4814 \n\
4815  p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4816  justification in x.\n\
4817 \n\
4818  p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4819  justification in y.\n\
4820 ";
4821 static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4822 Plot a glyph at the specified points\n\
4823 \n\
4824 DESCRIPTION:\n\
4825 \n\
4826  Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4827  because many[!] more glyphs are accessible with plstring.) The glyph\n\
4828  is specified with a PLplot user string. Note that the user string is\n\
4829  not actually limited to one glyph so it is possible (but not normally\n\
4830  useful) to plot more than one glyph at the specified points with this\n\
4831  function. As with plmtex and plptex, the user string can contain FCI\n\
4832  escapes to determine the font, UTF-8 code to determine the glyph or\n\
4833  else PLplot escapes for Hershey or unicode text to determine the\n\
4834  glyph.\n\
4835 \n\
4836  Redacted form: plstring(x, y, string)\n\
4837 \n\
4838  This function is used in examples 4, 21 and 26.\n\
4839 \n\
4840 \n\
4841 \n\
4842 SYNOPSIS:\n\
4843 \n\
4844 plstring(n, x, y, string)\n\
4845 \n\
4846 ARGUMENTS:\n\
4847 \n\
4848  n (PLINT, input) : Number of points in the x and y vectors.\n\
4849 \n\
4850  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4851  the points.\n\
4852 \n\
4853  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4854  the points.\n\
4855 \n\
4856  string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4857  the glyph(s) to be plotted at each of the n points.\n\
4858 ";
4859 static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
4860 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4861 \n\
4862 DESCRIPTION:\n\
4863 \n\
4864  As per plmapline, however the items are plotted as strings or points\n\
4865  in the same way as plstring.\n\
4866 \n\
4867  Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4868  maxy, plotentries)\n\
4869 \n\
4870  This function is not used in any examples.\n\
4871 \n\
4872 \n\
4873 \n\
4874 SYNOPSIS:\n\
4875 \n\
4876 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4877 \n\
4878 ARGUMENTS:\n\
4879 \n\
4880  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4881  transform the coordinates given in the shapefile into a plot\n\
4882  coordinate system. By using this transform, we can change from a\n\
4883  longitude, latitude coordinate to a polar stereographic project,\n\
4884  for example. Initially, x[0]..[n-1] are the longitudes and\n\
4885  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4886  mapform(), x[] and y[] should be replaced by the corresponding\n\
4887  plot coordinates. If no transform is desired, mapform can be\n\
4888  replaced by NULL.\n\
4889 \n\
4890  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4891  the file name of a set of Shapefile files without the file\n\
4892  extension.\n\
4893 \n\
4894  string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
4895  drawn.\n\
4896 \n\
4897  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
4898  be in the same units as used by the Shapefile. You could use a\n\
4899  very large negative number to plot everything, but you can improve\n\
4900  performance by limiting the area drawn. The units must match those\n\
4901  of the Shapefile projection, which may be for example longitude or\n\
4902  distance. The value of minx must be less than the value of maxx.\n\
4903 \n\
4904  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
4905  use a very large number to plot everything, but you can improve\n\
4906  performance by limiting the area drawn.\n\
4907 \n\
4908  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
4909  be in the same units as used by the Shapefile. You could use a\n\
4910  very large negative number to plot everything, but you can improve\n\
4911  performance by limiting the area drawn. The units must match those\n\
4912  of the Shapefile projection, which may be for example latitude or\n\
4913  distance. The value of miny must be less than the value of maxy.\n\
4914 \n\
4915  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
4916  use a very large number to plot everything, but you can improve\n\
4917  performance by limiting the area drawn.\n\
4918 \n\
4919  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
4920  zero-based indices of the Shapefile elements which will be drawn.\n\
4921  Setting\n\
4922  plotentries to NULL will plot all elements of the Shapefile.\n\
4923 \n\
4924  nplotentries (PLINT, input) : The number of items in\n\
4925  plotentries. Ignored if\n\
4926  plotentries is NULL.\n\
4927 ";
4928 static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
4929 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
4930 \n\
4931 DESCRIPTION:\n\
4932 \n\
4933  Sets up plotter environment for simple graphs by calling pladv and\n\
4934  setting up viewport and window to sensible default values. plenv0\n\
4935  leaves a standard margin (left-hand margin of eight character heights,\n\
4936  and a margin around the other three sides of five character heights)\n\
4937  around most graphs for axis labels and a title. When these defaults\n\
4938  are not suitable, use the individual routines plvpas, plvpor, or\n\
4939  plvasp for setting up the viewport, plwind for defining the window,\n\
4940  and plbox for drawing the box.\n\
4941 \n\
4942  Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4943 \n\
4944  This function is used in example 21.\n\
4945 \n\
4946 \n\
4947 \n\
4948 SYNOPSIS:\n\
4949 \n\
4950 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4951 \n\
4952 ARGUMENTS:\n\
4953 \n\
4954  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4955  world coordinates).\n\
4956 \n\
4957  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4958  world coordinates).\n\
4959 \n\
4960  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4961  coordinates).\n\
4962 \n\
4963  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4964  coordinates).\n\
4965 \n\
4966  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4967  scales will not be set, the user must set up the scale before\n\
4968  calling plenv0 using plsvpa, plvasp or other.\n\
4969  0: the x and y axes are scaled independently to use as much of\n\
4970  the screen as possible.\n\
4971  1: the scales of the x and y axes are made equal.\n\
4972  2: the axis of the x and y axes are made equal, and the plot\n\
4973  box will be square.\n\
4974 \n\
4975 \n\
4976  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4977  -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
4978  -1: draw box only.\n\
4979  0: draw box, ticks, and numeric tick labels.\n\
4980  1: also draw coordinate axes at x=0 and y=0.\n\
4981  2: also draw a grid at major tick positions in both\n\
4982  coordinates.\n\
4983  3: also draw a grid at minor tick positions in both\n\
4984  coordinates.\n\
4985  10: same as 0 except logarithmic x tick marks. (The x data\n\
4986  have to be converted to logarithms separately.)\n\
4987  11: same as 1 except logarithmic x tick marks. (The x data\n\
4988  have to be converted to logarithms separately.)\n\
4989  12: same as 2 except logarithmic x tick marks. (The x data\n\
4990  have to be converted to logarithms separately.)\n\
4991  13: same as 3 except logarithmic x tick marks. (The x data\n\
4992  have to be converted to logarithms separately.)\n\
4993  20: same as 0 except logarithmic y tick marks. (The y data\n\
4994  have to be converted to logarithms separately.)\n\
4995  21: same as 1 except logarithmic y tick marks. (The y data\n\
4996  have to be converted to logarithms separately.)\n\
4997  22: same as 2 except logarithmic y tick marks. (The y data\n\
4998  have to be converted to logarithms separately.)\n\
4999  23: same as 3 except logarithmic y tick marks. (The y data\n\
5000  have to be converted to logarithms separately.)\n\
5001  30: same as 0 except logarithmic x and y tick marks. (The x\n\
5002  and y data have to be converted to logarithms separately.)\n\
5003  31: same as 1 except logarithmic x and y tick marks. (The x\n\
5004  and y data have to be converted to logarithms separately.)\n\
5005  32: same as 2 except logarithmic x and y tick marks. (The x\n\
5006  and y data have to be converted to logarithms separately.)\n\
5007  33: same as 3 except logarithmic x and y tick marks. (The x\n\
5008  and y data have to be converted to logarithms separately.)\n\
5009  40: same as 0 except date / time x labels.\n\
5010  41: same as 1 except date / time x labels.\n\
5011  42: same as 2 except date / time x labels.\n\
5012  43: same as 3 except date / time x labels.\n\
5013  50: same as 0 except date / time y labels.\n\
5014  51: same as 1 except date / time y labels.\n\
5015  52: same as 2 except date / time y labels.\n\
5016  53: same as 3 except date / time y labels.\n\
5017  60: same as 0 except date / time x and y labels.\n\
5018  61: same as 1 except date / time x and y labels.\n\
5019  62: same as 2 except date / time x and y labels.\n\
5020  63: same as 3 except date / time x and y labels.\n\
5021  70: same as 0 except custom x and y labels.\n\
5022  71: same as 1 except custom x and y labels.\n\
5023  72: same as 2 except custom x and y labels.\n\
5024  73: same as 3 except custom x and y labels.\n\
5025 ";
5026 static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
5027 Configure the transformations required for projecting a 3D surface on a 2D window\n\
5028 \n\
5029 DESCRIPTION:\n\
5030 \n\
5031  Configure the transformations required for projecting a 3D surface on\n\
5032  an existing 2D window. Those transformations (see the PLplot\n\
5033  documentation) are done to a rectangular cuboid enclosing the 3D\n\
5034  surface which has its limits expressed in 3D world coordinates and\n\
5035  also normalized 3D coordinates (used for interpreting the altitude and\n\
5036  azimuth of the viewing angle). The transformations consist of the\n\
5037  linear transform from 3D world coordinates to normalized 3D\n\
5038  coordinates, and the 3D rotation of normalized coordinates required to\n\
5039  align the pole of the new 3D coordinate system with the viewing\n\
5040  direction specified by altitude and azimuth so that x and y of the\n\
5041  surface elements in that transformed coordinate system are the\n\
5042  projection of the 3D surface with given viewing direction on the 2D\n\
5043  window.\n\
5044 \n\
5045  The enclosing rectangular cuboid for the surface plot is defined by\n\
5046  xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
5047  mapped into the same rectangular cuboid with normalized 3D coordinate\n\
5048  sizes of basex by basey by height so that xmin maps to -\n\
5049  basex/2, xmax maps to basex/2, ymin maps to -\n\
5050  basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
5051  The resulting rectangular cuboid in normalized coordinates is then\n\
5052  viewed by an observer at altitude alt and azimuth az. This routine\n\
5053  must be called before plbox3 or any of the 3D surface plotting\n\
5054  routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
5055  plsurf3dl or plfill3.\n\
5056 \n\
5057  Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
5058  zmin, zmax, alt, az)\n\
5059 \n\
5060  This function is examples 8, 11, 18, and 21.\n\
5061 \n\
5062 \n\
5063 \n\
5064 SYNOPSIS:\n\
5065 \n\
5066 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
5067 \n\
5068 ARGUMENTS:\n\
5069 \n\
5070  basex (PLFLT, input) : The normalized x coordinate size of the\n\
5071  rectangular cuboid.\n\
5072 \n\
5073  basey (PLFLT, input) : The normalized y coordinate size of the\n\
5074  rectangular cuboid.\n\
5075 \n\
5076  height (PLFLT, input) : The normalized z coordinate size of the\n\
5077  rectangular cuboid.\n\
5078 \n\
5079  xmin (PLFLT, input) : The minimum x world coordinate of the\n\
5080  rectangular cuboid.\n\
5081 \n\
5082  xmax (PLFLT, input) : The maximum x world coordinate of the\n\
5083  rectangular cuboid.\n\
5084 \n\
5085  ymin (PLFLT, input) : The minimum y world coordinate of the\n\
5086  rectangular cuboid.\n\
5087 \n\
5088  ymax (PLFLT, input) : The maximum y world coordinate of the\n\
5089  rectangular cuboid.\n\
5090 \n\
5091  zmin (PLFLT, input) : The minimum z world coordinate of the\n\
5092  rectangular cuboid.\n\
5093 \n\
5094  zmax (PLFLT, input) : The maximum z world coordinate of the\n\
5095  rectangular cuboid.\n\
5096 \n\
5097  alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
5098  plane of the rectangular cuboid in normalized coordinates.\n\
5099 \n\
5100  az (PLFLT, input) : The viewing azimuth in degrees of the\n\
5101  rectangular cuboid in normalized coordinates. When az=0, the\n\
5102  observer is looking face onto the zx plane of the rectangular\n\
5103  cuboid in normalized coordinates, and as az is increased, the\n\
5104  observer moves clockwise around that cuboid when viewed from above\n\
5105  the xy plane.\n\
5106 ";
5107 static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
5108 Draw filled polygon\n\
5109 \n\
5110 DESCRIPTION:\n\
5111 \n\
5112  Fills the polygon defined by the n points (\n\
5113  x[i],\n\
5114  y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
5115  style is a solid fill. The routine will automatically close the\n\
5116  polygon between the last and first vertices. If multiple closed\n\
5117  polygons are passed in x and y then plfill will fill in between them.\n\
5118 \n\
5119  Redacted form: plfill(x,y)\n\
5120 \n\
5121  This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
5122 \n\
5123 \n\
5124 \n\
5125 SYNOPSIS:\n\
5126 \n\
5127 plfill(n, x, y)\n\
5128 \n\
5129 ARGUMENTS:\n\
5130 \n\
5131  n (PLINT, input) : Number of vertices in polygon.\n\
5132 \n\
5133  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5134  vertices.\n\
5135 \n\
5136  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5137  vertices.\n\
5138 ";
5139 static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
5140 Magnitude colored plot surface with contour\n\
5141 \n\
5142 DESCRIPTION:\n\
5143 \n\
5144  Aside from dropping the\n\
5145  side functionality this is a more powerful form of plot3d: the surface\n\
5146  mesh can be colored accordingly to the current z value being plotted,\n\
5147  a contour plot can be drawn at the base XY plane, and a curtain can be\n\
5148  drawn between the plotted function border and the base XY plane. The\n\
5149  arguments are identical to those of plmeshc. The only difference\n\
5150  between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
5151  the surface, while plot3dc only draws the surface as viewed from the\n\
5152  top.\n\
5153 \n\
5154  Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
5155 \n\
5156 \n\
5157  This function is used in example 21.\n\
5158 \n\
5159 \n\
5160 \n\
5161 SYNOPSIS:\n\
5162 \n\
5163 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
5164 \n\
5165 ARGUMENTS:\n\
5166 \n\
5167  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5168  which the function is evaluated.\n\
5169 \n\
5170  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5171  which the function is evaluated.\n\
5172 \n\
5173  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5174  plot. Should have dimensions of\n\
5175  nx by\n\
5176  ny.\n\
5177 \n\
5178  nx (PLINT, input) : Number of x values at which function is\n\
5179  evaluated.\n\
5180 \n\
5181  ny (PLINT, input) : Number of y values at which function is\n\
5182  evaluated.\n\
5183 \n\
5184  opt (PLINT, input) : Determines the way in which the surface is\n\
5185  represented. To specify more than one option just add the options,\n\
5186  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
5187  showing z as a function of x for each value of y[j] .\n\
5188  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5189  for each value of x[i] .\n\
5190  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5191  at which function is defined.\n\
5192  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
5193  the z value being plotted. The color is used from the current\n\
5194  cmap1.\n\
5195  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5196  using parameters\n\
5197  nlevel and\n\
5198  clevel.\n\
5199  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5200  the borders of the plotted function.\n\
5201 \n\
5202 \n\
5203  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5204  levels.\n\
5205 \n\
5206  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5207 ";
5208 static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
5209 Write text relative to viewport boundaries\n\
5210 \n\
5211 DESCRIPTION:\n\
5212 \n\
5213  Writes text at a specified position relative to the viewport\n\
5214  boundaries. Text may be written inside or outside the viewport, but\n\
5215  is clipped at the subpage boundaries. The reference point of a string\n\
5216  lies along a line passing through the string at half the height of a\n\
5217  capital letter. The position of the reference point along this line\n\
5218  is determined by just, and the position of the reference point\n\
5219  relative to the viewport is set by disp and pos.\n\
5220 \n\
5221  Redacted form: General: plmtex(side, disp, pos, just, text)\n\
5222 \n\
5223 \n\
5224  This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
5225  26.\n\
5226 \n\
5227 \n\
5228 \n\
5229 SYNOPSIS:\n\
5230 \n\
5231 plmtex(side, disp, pos, just, text)\n\
5232 \n\
5233 ARGUMENTS:\n\
5234 \n\
5235  side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5236  the side of the viewport along which the text is to be written.\n\
5237  The string must be one of: b: Bottom of viewport, text written\n\
5238  parallel to edge.\n\
5239  bv: Bottom of viewport, text written at right angles to edge.\n\
5240  l: Left of viewport, text written parallel to edge.\n\
5241  lv: Left of viewport, text written at right angles to edge.\n\
5242  r: Right of viewport, text written parallel to edge.\n\
5243  rv: Right of viewport, text written at right angles to edge.\n\
5244  t: Top of viewport, text written parallel to edge.\n\
5245  tv: Top of viewport, text written at right angles to edge.\n\
5246 \n\
5247 \n\
5248  disp (PLFLT, input) : Position of the reference point of string,\n\
5249  measured outwards from the specified viewport edge in units of the\n\
5250  current character height. Use negative disp to write within the\n\
5251  viewport.\n\
5252 \n\
5253  pos (PLFLT, input) : Position of the reference point of string\n\
5254  along the specified edge, expressed as a fraction of the length of\n\
5255  the edge.\n\
5256 \n\
5257  just (PLFLT, input) : Specifies the position of the string relative\n\
5258  to its reference point. If just=0. , the reference point is at\n\
5259  the left and if just=1. , it is at the right of the string. Other\n\
5260  values of just give intermediate justifications.\n\
5261 \n\
5262  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5263  written out.\n\
5264 ";
5265 static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
5266 Set arrow style for vector plots\n\
5267 \n\
5268 DESCRIPTION:\n\
5269 \n\
5270  Set the style for the arrow used by plvect to plot vectors.\n\
5271 \n\
5272  Redacted form: plsvect(arrowx, arrowy, fill)\n\
5273 \n\
5274  This function is used in example 22.\n\
5275 \n\
5276 \n\
5277 \n\
5278 SYNOPSIS:\n\
5279 \n\
5280 plsvect(arrowx, arrowy, npts, fill)\n\
5281 \n\
5282 ARGUMENTS:\n\
5283 \n\
5284  arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
5285  the x and y points which make up the arrow. The arrow is plotted\n\
5286  by joining these points to form a polygon. The scaling assumes\n\
5287  that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
5288  <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
5289  will be reset to its default.\n\
5290 \n\
5291  npts (PLINT, input) : Number of points in the vectors arrowx and\n\
5292  arrowy.\n\
5293 \n\
5294  fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
5295  fill is false then the arrow is open.\n\
5296 ";
5297 static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5298 Get family file parameters\n\
5299 \n\
5300 DESCRIPTION:\n\
5301 \n\
5302  Gets information about current family file, if familying is enabled.\n\
5303  See the PLplot documentation for more information.\n\
5304 \n\
5305  Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5306 \n\
5307  This function is used in examples 14 and 31.\n\
5308 \n\
5309 \n\
5310 \n\
5311 SYNOPSIS:\n\
5312 \n\
5313 plgfam(p_fam, p_num, p_bmax)\n\
5314 \n\
5315 ARGUMENTS:\n\
5316 \n\
5317  p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5318  family flag value. If nonzero, familying is enabled for the\n\
5319  current device.\n\
5320 \n\
5321  p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5322  family file number.\n\
5323 \n\
5324  p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5325  file size (in bytes) for a family file.\n\
5326 ";
5327 static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
5328 Random number generator returning a real random number in the range [0,1]\n\
5329 \n\
5330 DESCRIPTION:\n\
5331 \n\
5332  Random number generator returning a real random number in the range\n\
5333  [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5334  / compilers provide their own random number generator, and so this is\n\
5335  provided purely for convenience and to give a consistent random number\n\
5336  generator across all languages supported by PLplot. This is\n\
5337  particularly useful for comparing results from the test suite of\n\
5338  examples.\n\
5339 \n\
5340  Redacted form: plrandd()\n\
5341 \n\
5342  This function is used in examples 17 and 21.\n\
5343 \n\
5344 \n\
5345 \n\
5346 SYNOPSIS:\n\
5347 \n\
5348 plrandd()\n\
5349 ";
5350 static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5351 Contour plot\n\
5352 \n\
5353 DESCRIPTION:\n\
5354 \n\
5355  Draws a contour plot of the data in f[\n\
5356  nx][\n\
5357  ny], using the nlevel contour levels specified by clevel. Only the\n\
5358  region of the matrix from kx to lx and from ky to ly is plotted out\n\
5359  where all these index ranges are interpreted as one-based for\n\
5360  historical reasons. A transformation routine pointed to by pltr with\n\
5361  a generic pointer pltr_data for additional data required by the\n\
5362  transformation routine is used to map indices within the matrix to the\n\
5363  world coordinates.\n\
5364 \n\
5365  Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5366  where (see above discussion) the pltr, pltr_data callback arguments\n\
5367  are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5368  vectors; or xg and yg matrices.\n\
5369 \n\
5370  This function is used in examples 9, 14, 16, and 22.\n\
5371 \n\
5372 \n\
5373 \n\
5374 SYNOPSIS:\n\
5375 \n\
5376 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5377 \n\
5378 ARGUMENTS:\n\
5379 \n\
5380  f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5381 \n\
5382  nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5383 \n\
5384  kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5385  kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5386  zero-based for historical backwards-compatibility reasons.\n\
5387 \n\
5388  ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5389  ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5390  zero-based for historical backwards-compatibility reasons.\n\
5391 \n\
5392  clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5393  which to draw contours.\n\
5394 \n\
5395  nlevel (PLINT, input) : Number of contour levels to draw.\n\
5396 \n\
5397  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5398  defines the transformation between the zero-based indices of the\n\
5399  matrix f and the world coordinates.For the C case, transformation\n\
5400  functions are provided in the PLplot library: pltr0 for the\n\
5401  identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5402  respectively defined by vectors and matrices. In addition, C\n\
5403  callback routines for the transformation can be supplied by the\n\
5404  user such as the mypltr function in examples/c/x09c.c which\n\
5405  provides a general linear transformation between index coordinates\n\
5406  and world coordinates.For languages other than C you should\n\
5407  consult the PLplot documentation for the details concerning how\n\
5408  PLTRANSFORM_callback arguments are interfaced. However, in\n\
5409  general, a particular pattern of callback-associated arguments\n\
5410  such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5411  yg matrices are respectively interfaced to a linear-transformation\n\
5412  routine similar to the above mypltr function; pltr1; and pltr2.\n\
5413  Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5414  the PLplot documentation) support native language callbacks for\n\
5415  handling index to world-coordinate transformations. Examples of\n\
5416  these various approaches are given in examples/<language>x09*,\n\
5417  examples/<language>x16*, examples/<language>x20*,\n\
5418  examples/<language>x21*, and examples/<language>x22*, for all our\n\
5419  supported languages.\n\
5420 \n\
5421  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5422  information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5423  that is externally supplied.\n\
5424 ";
5425 static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
5426 Set line style\n\
5427 \n\
5428 DESCRIPTION:\n\
5429 \n\
5430  This sets up the line style for all lines subsequently drawn. A line\n\
5431  consists of segments in which the pen is alternately down and up. The\n\
5432  lengths of these segments are passed in the vectors mark and space\n\
5433  respectively. The number of mark-space pairs is specified by nms. In\n\
5434  order to return the line style to the default continuous line, plstyl\n\
5435  should be called with nms =0 .(see also pllsty)\n\
5436 \n\
5437  Redacted form: plstyl(mark, space)\n\
5438 \n\
5439  This function is used in examples 1, 9, and 14.\n\
5440 \n\
5441 \n\
5442 \n\
5443 SYNOPSIS:\n\
5444 \n\
5445 plstyl(nms, mark, space)\n\
5446 \n\
5447 ARGUMENTS:\n\
5448 \n\
5449  nms (PLINT, input) : The number of mark and space elements in a\n\
5450  line. Thus a simple broken line can be obtained by setting nms=1\n\
5451  . A continuous line is specified by setting nms=0 .\n\
5452 \n\
5453  mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5454  segments during which the pen is down, measured in micrometers.\n\
5455 \n\
5456  space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5457  the segments during which the pen is up, measured in micrometers.\n\
5458 ";
5459 static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
5460 Set the cmap0 palette using the specified cmap0*.pal format file\n\
5461 \n\
5462 DESCRIPTION:\n\
5463 \n\
5464  Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5465 \n\
5466  Redacted form: plspal0(filename)\n\
5467 \n\
5468  This function is in example 16.\n\
5469 \n\
5470 \n\
5471 \n\
5472 SYNOPSIS:\n\
5473 \n\
5474 plspal0(filename)\n\
5475 \n\
5476 ARGUMENTS:\n\
5477 \n\
5478  filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5479  containing the name of the cmap0*.pal file. If this string is\n\
5480  empty, use the default cmap0*.pal file.\n\
5481 ";
5482 static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
5483 Set the cmap1 palette using the specified cmap1*.pal format file\n\
5484 \n\
5485 DESCRIPTION:\n\
5486 \n\
5487  Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5488 \n\
5489  Redacted form: plspal1(filename, interpolate)\n\
5490 \n\
5491  This function is used in example 16.\n\
5492 \n\
5493 \n\
5494 \n\
5495 SYNOPSIS:\n\
5496 \n\
5497 plspal1(filename, interpolate)\n\
5498 \n\
5499 ARGUMENTS:\n\
5500 \n\
5501  filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5502  containing the name of the cmap1*.pal file. If this string is\n\
5503  empty, use the default cmap1*.pal file.\n\
5504 \n\
5505  interpolate (PLBOOL, input) : If this parameter is true, the\n\
5506  columns containing the intensity index, r, g, b, alpha and\n\
5507  alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5508  palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5509  a flag which controls whether the r, g, b data sent to plscmap1la\n\
5510  are interpreted as HLS or RGB.) If this parameter is false, the\n\
5511  intensity index and alt_hue_path columns are ignored and the r, g,\n\
5512  b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5513  are used instead to set the cmap1 palette directly with a call to\n\
5514  plscmap1a.\n\
5515 ";
5516 static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
5517 Set current output stream\n\
5518 \n\
5519 DESCRIPTION:\n\
5520 \n\
5521  Sets the number of the current output stream. The stream number\n\
5522  defaults to 0 unless changed by this routine. The first use of this\n\
5523  routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5524 \n\
5525  Redacted form: plsstrm(strm)\n\
5526 \n\
5527  This function is examples 1,14,20.\n\
5528 \n\
5529 \n\
5530 \n\
5531 SYNOPSIS:\n\
5532 \n\
5533 plsstrm(strm)\n\
5534 \n\
5535 ARGUMENTS:\n\
5536 \n\
5537  strm (PLINT, input) : The current stream number.\n\
5538 ";
5539 static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
5540 Specify viewport using normalized subpage coordinates\n\
5541 \n\
5542 DESCRIPTION:\n\
5543 \n\
5544  Device-independent routine for setting up the viewport. This defines\n\
5545  the viewport in terms of normalized subpage coordinates which run from\n\
5546  0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5547  current subpage. Use the alternate routine plsvpa in order to create\n\
5548  a viewport of a definite size.\n\
5549 \n\
5550  Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5551 \n\
5552  This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5553  24, 26, 27, and 31.\n\
5554 \n\
5555 \n\
5556 \n\
5557 SYNOPSIS:\n\
5558 \n\
5559 plvpor(xmin, xmax, ymin, ymax)\n\
5560 \n\
5561 ARGUMENTS:\n\
5562 \n\
5563  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5564  left-hand edge of the viewport.\n\
5565 \n\
5566  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5567  right-hand edge of the viewport.\n\
5568 \n\
5569  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5570  bottom edge of the viewport.\n\
5571 \n\
5572  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5573  edge of the viewport.\n\
5574 ";
5575 static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
5576 Write text inside the viewport\n\
5577 \n\
5578 DESCRIPTION:\n\
5579 \n\
5580  Writes text at a specified position and inclination within the\n\
5581  viewport. Text is clipped at the viewport boundaries. The reference\n\
5582  point of a string lies along a line passing through the string at half\n\
5583  the height of a capital letter. The position of the reference point\n\
5584  along this line is determined by just, the reference point is placed\n\
5585  at world coordinates (\n\
5586  x,\n\
5587  y) within the viewport. The inclination of the string is specified\n\
5588  in terms of differences of world coordinates making it easy to write\n\
5589  text parallel to a line in a graph.\n\
5590 \n\
5591  Redacted form: plptex(x, y, dx, dy, just, text)\n\
5592 \n\
5593  This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5594 \n\
5595 \n\
5596 \n\
5597 SYNOPSIS:\n\
5598 \n\
5599 plptex(x, y, dx, dy, just, text)\n\
5600 \n\
5601 ARGUMENTS:\n\
5602 \n\
5603  x (PLFLT, input) : x coordinate of reference point of string.\n\
5604 \n\
5605  y (PLFLT, input) : y coordinate of reference point of string.\n\
5606 \n\
5607  dx (PLFLT, input) : Together with dy, this specifies the\n\
5608  inclination of the string. The baseline of the string is parallel\n\
5609  to a line joining (\n\
5610  x,\n\
5611  y) to (\n\
5612  x+\n\
5613  dx,\n\
5614  y+\n\
5615  dy) .\n\
5616 \n\
5617  dy (PLFLT, input) : Together with dx, this specifies the\n\
5618  inclination of the string.\n\
5619 \n\
5620  just (PLFLT, input) : Specifies the position of the string relative\n\
5621  to its reference point. If just=0. , the reference point is at\n\
5622  the left and if just=1. , it is at the right of the string. Other\n\
5623  values of just give intermediate justifications.\n\
5624 \n\
5625  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5626  written out.\n\
5627 ";
5628 static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
5629 Set z axis parameters\n\
5630 \n\
5631 DESCRIPTION:\n\
5632 \n\
5633  Identical to plsxax, except that arguments are flags for z axis. See\n\
5634  the description of plsxax for more detail.\n\
5635 \n\
5636  Redacted form: plszax(digmax, digits)\n\
5637 \n\
5638  This function is used in example 31.\n\
5639 \n\
5640 \n\
5641 \n\
5642 SYNOPSIS:\n\
5643 \n\
5644 plszax(digmax, digits)\n\
5645 \n\
5646 ARGUMENTS:\n\
5647 \n\
5648  digmax (PLINT, input) : Variable to set the maximum number of\n\
5649  digits for the z axis. If nonzero, the printed label will be\n\
5650  switched to a floating-point representation when the number of\n\
5651  digits exceeds digmax.\n\
5652 \n\
5653  digits (PLINT, input) : Field digits value. Currently, changing\n\
5654  its value here has no effect since it is set only by plbox or\n\
5655  plbox3. However, the user may obtain its value after a call to\n\
5656  either of these functions by calling plgzax.\n\
5657 ";
5658 static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
5659 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5660 \n\
5661 DESCRIPTION:\n\
5662 \n\
5663  This variant of plsurf3d (see that function\'s documentation for more\n\
5664  details) should be suitable for the case where the area of the x, y\n\
5665  coordinate grid where z is defined can be non-rectangular. The limits\n\
5666  of that grid are provided by the parameters indexxmin, indexxmax,\n\
5667  indexymin, and indexymax.\n\
5668 \n\
5669  Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5670  indexymax)\n\
5671 \n\
5672  This function is used in example 8.\n\
5673 \n\
5674 \n\
5675 \n\
5676 SYNOPSIS:\n\
5677 \n\
5678 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5679 \n\
5680 ARGUMENTS:\n\
5681 \n\
5682  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5683  which the function is evaluated.\n\
5684 \n\
5685  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5686  which the function is evaluated.\n\
5687 \n\
5688  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5689  plot. Should have dimensions of\n\
5690  nx by\n\
5691  ny.\n\
5692 \n\
5693  nx (PLINT, input) : Number of x values at which function is\n\
5694  evaluated.\n\
5695 \n\
5696  ny (PLINT, input) : Number of y values at which function is\n\
5697  evaluated.\n\
5698 \n\
5699  opt (PLINT, input) : Determines the way in which the surface is\n\
5700  represented. To specify more than one option just add the options,\n\
5701  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5702  connecting points at which function is defined.\n\
5703  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5704  using parameters\n\
5705  nlevel and\n\
5706  clevel.\n\
5707  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5708  using parameters\n\
5709  nlevel and\n\
5710  clevel.\n\
5711  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5712  the borders of the plotted function.\n\
5713  opt=MAG_COLOR : the surface is colored according to the value\n\
5714  of Z; if MAG_COLOR is not used, then the surface is colored\n\
5715  according to the intensity of the reflected light in the\n\
5716  surface from a light source whose position is set using\n\
5717  pllightsource.\n\
5718 \n\
5719 \n\
5720  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5721  levels.\n\
5722 \n\
5723  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5724 \n\
5725  indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5726  corresponds to the first x index where z is defined.\n\
5727 \n\
5728  indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5729  which corresponds (by convention) to one more than the last x\n\
5730  index value where z is defined.\n\
5731 \n\
5732  indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5733  values which all must be ≥ 0. These values are the first y index\n\
5734  where z is defined for a particular x index in the range from\n\
5735  indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5736  indexxmax.\n\
5737 \n\
5738  indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5739  values which all must be ≤ ny. These values correspond (by\n\
5740  convention) to one more than the last y index where z is defined\n\
5741  for a particular x index in the range from indexxmin to indexxmax\n\
5742  - 1. The dimension of indexymax is indexxmax.\n\
5743 ";
5744 static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
5745 Set font\n\
5746 \n\
5747 DESCRIPTION:\n\
5748 \n\
5749  Sets the font used for subsequent text and symbols. For devices that\n\
5750  still use Hershey fonts this routine has no effect unless the Hershey\n\
5751  fonts with extended character set are loaded (see plfontld). For\n\
5752  unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5753  this routine calls the plsfci routine with argument set up\n\
5754  appropriately for the various cases below. However, this method of\n\
5755  specifying the font for unicode-aware devices is deprecated, and the\n\
5756  much more flexible method of calling plsfont directly is recommended\n\
5757  instead (where plsfont provides a user-friendly interface to plsfci),\n\
5758 \n\
5759  Redacted form: plfont(ifont)\n\
5760 \n\
5761  This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5762 \n\
5763 \n\
5764 \n\
5765 SYNOPSIS:\n\
5766 \n\
5767 plfont(ifont)\n\
5768 \n\
5769 ARGUMENTS:\n\
5770 \n\
5771  ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5772  (simplest and fastest)\n\
5773  2: Serif font\n\
5774  3: Italic font\n\
5775  4: Script font\n\
5776 ";
5777 static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
5778 Get the cmap1 argument range for continuous color plots\n\
5779 \n\
5780 DESCRIPTION:\n\
5781 \n\
5782  Get the cmap1 argument range for continuous color plots. (Use\n\
5783  plscmap1_range to set the cmap1 argument range.)\n\
5784 \n\
5785  Redacted form: plgcmap1_range(min_color, max_color)\n\
5786 \n\
5787  This function is currently not used in any example.\n\
5788 \n\
5789 \n\
5790 \n\
5791 SYNOPSIS:\n\
5792 \n\
5793 plgcmap1_range(min_color, max_color)\n\
5794 \n\
5795 ARGUMENTS:\n\
5796 \n\
5797  min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5798  minimum cmap1 argument.\n\
5799 \n\
5800  max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5801  maximum cmap1 argument.\n\
5802 ";
5803 static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
5804 Set the cmap1 argument range for continuous color plots\n\
5805 \n\
5806 DESCRIPTION:\n\
5807 \n\
5808  Set the cmap1 argument range for continuous color plots that\n\
5809  corresponds to the range of data values. The maximum range\n\
5810  corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5811  the cmap1 argument range that is specified with this routine, the\n\
5812  smaller the subset of the cmap1 color palette that is used to\n\
5813  represent the continuous data being plotted. If\n\
5814  min_color is greater than\n\
5815  max_color or\n\
5816  max_color is greater than 1.0 or\n\
5817  min_color is less than 0.0 then no change is made to the cmap1\n\
5818  argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5819 \n\
5820  Redacted form: plscmap1_range(min_color, max_color)\n\
5821 \n\
5822  This function is currently used in example 33.\n\
5823 \n\
5824 \n\
5825 \n\
5826 SYNOPSIS:\n\
5827 \n\
5828 plscmap1_range(min_color, max_color)\n\
5829 \n\
5830 ARGUMENTS:\n\
5831 \n\
5832  min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5833  than 0.0, then 0.0 is used instead.\n\
5834 \n\
5835  max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5836  than 1.0, then 1.0 is used instead.\n\
5837 ";
5838 static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
5839 Draw a circular or elliptical arc\n\
5840 \n\
5841 DESCRIPTION:\n\
5842 \n\
5843  Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5844  semiminor axis b, starting at angle1 and ending at angle2.\n\
5845 \n\
5846  Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5847  fill)\n\
5848 \n\
5849 \n\
5850  This function is used in examples 3 and 27.\n\
5851 \n\
5852 \n\
5853 \n\
5854 SYNOPSIS:\n\
5855 \n\
5856 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5857 \n\
5858 ARGUMENTS:\n\
5859 \n\
5860  x (PLFLT, input) : X coordinate of arc center.\n\
5861 \n\
5862  y (PLFLT, input) : Y coordinate of arc center.\n\
5863 \n\
5864  a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5865 \n\
5866  b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5867 \n\
5868  angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5869  semimajor axis.\n\
5870 \n\
5871  angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5872  semimajor axis.\n\
5873 \n\
5874  rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5875  X-axis.\n\
5876 \n\
5877  fill (PLBOOL, input) : Draw a filled arc.\n\
5878 ";
5879 static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5880 Plot 3-d surface plot\n\
5881 \n\
5882 DESCRIPTION:\n\
5883 \n\
5884  Plots a three-dimensional surface plot within the environment set up\n\
5885  by plw3d. The surface is defined by the matrix z[\n\
5886  nx][\n\
5887  ny] , the point z[i][j] being the value of the function at (\n\
5888  x[i],\n\
5889  y[j]). Note that the points in vectors x and y do not need to be\n\
5890  equally spaced, but must be stored in ascending order. The parameter\n\
5891  opt controls the way in which the surface is displayed. For further\n\
5892  details see the PLplot documentation. The only difference between\n\
5893  plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5894  while plot3d only draws the surface as viewed from the top.\n\
5895 \n\
5896  Redacted form: plot3d(x, y, z, opt, side)\n\
5897 \n\
5898  This function is used in examples 11 and 21.\n\
5899 \n\
5900 \n\
5901 \n\
5902 SYNOPSIS:\n\
5903 \n\
5904 plot3d(x, y, z, nx, ny, opt, side)\n\
5905 \n\
5906 ARGUMENTS:\n\
5907 \n\
5908  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5909  which the function is evaluated.\n\
5910 \n\
5911  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5912  which the function is evaluated.\n\
5913 \n\
5914  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5915  plot. Should have dimensions of\n\
5916  nx by\n\
5917  ny.\n\
5918 \n\
5919  nx (PLINT, input) : Number of x values at which function is\n\
5920  evaluated.\n\
5921 \n\
5922  ny (PLINT, input) : Number of y values at which function is\n\
5923  evaluated.\n\
5924 \n\
5925  opt (PLINT, input) : Determines the way in which the surface is\n\
5926  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5927  function of x for each value of y[j] .\n\
5928  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5929  for each value of x[i] .\n\
5930  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5931  at which function is defined.\n\
5932 \n\
5933 \n\
5934  side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5935  should be draw on the figure. If side is true sides are drawn,\n\
5936  otherwise no sides are drawn.\n\
5937 ";
5938 static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5939 Set area line fill pattern\n\
5940 \n\
5941 DESCRIPTION:\n\
5942 \n\
5943  Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5944  The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5945  inclinations and spacings. The arguments to this routine are the\n\
5946  number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5947  elements) specifying the inclinations in tenths of a degree and the\n\
5948  spacing in micrometers. (See also plpsty)\n\
5949 \n\
5950  Redacted form: General: plpat(inc, del)\n\
5951 \n\
5952 \n\
5953  This function is used in example 15.\n\
5954 \n\
5955 \n\
5956 \n\
5957 SYNOPSIS:\n\
5958 \n\
5959 plpat(nlin, inc, del)\n\
5960 \n\
5961 ARGUMENTS:\n\
5962 \n\
5963  nlin (PLINT, input) : Number of sets of lines making up the\n\
5964  pattern, either 1 or 2.\n\
5965 \n\
5966  inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5967  inclination in tenths of a degree. (Should be between -900 and\n\
5968  900).\n\
5969 \n\
5970  del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5971  spacing in micrometers between the lines making up the pattern.\n\
5972 ";
5973 static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
5974 Get x axis parameters\n\
5975 \n\
5976 DESCRIPTION:\n\
5977 \n\
5978  Returns current values of the p_digmax and p_digits flags for the x\n\
5979  axis. p_digits is updated after the plot is drawn, so this routine\n\
5980  should only be called after the call to plbox (or plbox3) is complete.\n\
5981  See the PLplot documentation for more information.\n\
5982 \n\
5983  Redacted form: plgxax(p_digmax, p_digits)\n\
5984 \n\
5985  This function is used in example 31.\n\
5986 \n\
5987 \n\
5988 \n\
5989 SYNOPSIS:\n\
5990 \n\
5991 plgxax(p_digmax, p_digits)\n\
5992 \n\
5993 ARGUMENTS:\n\
5994 \n\
5995  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5996  number of digits for the x axis. If nonzero, the printed label\n\
5997  has been switched to a floating-point representation when the\n\
5998  number of digits exceeds this value.\n\
5999 \n\
6000  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6001  number of digits for the numeric labels (x axis) from the last\n\
6002  plot.\n\
6003 ";
6004 static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
6005 Draw filled polygon in 3D\n\
6006 \n\
6007 DESCRIPTION:\n\
6008 \n\
6009  Fills the 3D polygon defined by the n points in the x, y, and z\n\
6010  vectors using the pattern defined by plpsty or plpat. The routine\n\
6011  will automatically close the polygon between the last and first\n\
6012  vertices. If multiple closed polygons are passed in x, y, and z then\n\
6013  plfill3 will fill in between them.\n\
6014 \n\
6015  Redacted form: General: plfill3(x, y, z)\n\
6016 \n\
6017 \n\
6018  This function is used in example 15.\n\
6019 \n\
6020 \n\
6021 \n\
6022 SYNOPSIS:\n\
6023 \n\
6024 plfill3(n, x, y, z)\n\
6025 \n\
6026 ARGUMENTS:\n\
6027 \n\
6028  n (PLINT, input) : Number of vertices in polygon.\n\
6029 \n\
6030  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6031  vertices.\n\
6032 \n\
6033  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6034  vertices.\n\
6035 \n\
6036  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6037  vertices.\n\
6038 ";
6039 static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6040 Set color, cmap0\n\
6041 \n\
6042 DESCRIPTION:\n\
6043 \n\
6044  Sets the color index for cmap0 (see the PLplot documentation).\n\
6045 \n\
6046  Redacted form: plcol0(icol0)\n\
6047 \n\
6048  This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6049 \n\
6050 \n\
6051 \n\
6052 SYNOPSIS:\n\
6053 \n\
6054 plcol0(icol0)\n\
6055 \n\
6056 ARGUMENTS:\n\
6057 \n\
6058  icol0 (PLINT, input) : Integer representing the color. The\n\
6059  defaults at present are (these may change):\n\
6060  0 black (default background)\n\
6061  1 red (default foreground)\n\
6062  2 yellow\n\
6063  3 green\n\
6064  4 aquamarine\n\
6065  5 pink\n\
6066  6 wheat\n\
6067  7 grey\n\
6068  8 brown\n\
6069  9 blue\n\
6070  10 BlueViolet\n\
6071  11 cyan\n\
6072  12 turquoise\n\
6073  13 magenta\n\
6074  14 salmon\n\
6075  15 white\n\
6076 \n\
6077  Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6078  change an individual color in the cmap0 color palette.\n\
6079 ";
6080 static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
6081 Draw text at points defined by Shapefile data in world coordinates\n\
6082 \n\
6083 DESCRIPTION:\n\
6084 \n\
6085  As per plmapline, however the items are plotted as text in the same\n\
6086  way as plptex.\n\
6087 \n\
6088  Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
6089  miny, maxy, plotentry)\n\
6090 \n\
6091  This function is used in example 19.\n\
6092 \n\
6093 \n\
6094 \n\
6095 SYNOPSIS:\n\
6096 \n\
6097 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
6098 \n\
6099 ARGUMENTS:\n\
6100 \n\
6101  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6102  transform the coordinates given in the shapefile into a plot\n\
6103  coordinate system. By using this transform, we can change from a\n\
6104  longitude, latitude coordinate to a polar stereographic project,\n\
6105  for example. Initially, x[0]..[n-1] are the longitudes and\n\
6106  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6107  mapform(), x[] and y[] should be replaced by the corresponding\n\
6108  plot coordinates. If no transform is desired, mapform can be\n\
6109  replaced by NULL.\n\
6110 \n\
6111  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6112  the file name of a set of Shapefile files without the file\n\
6113  extension.\n\
6114 \n\
6115  dx (PLFLT, input) : Used to define the slope of the texts which is\n\
6116  dy/dx.\n\
6117 \n\
6118  dy (PLFLT, input) : Used to define the slope of the texts which is\n\
6119  dy/dx.\n\
6120 \n\
6121  just (PLFLT, input) : Set the justification of the text. The value\n\
6122  given will be the fraction of the distance along the string that\n\
6123  sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
6124  centralized text and 1.0 gives right aligned text.\n\
6125 \n\
6126  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
6127 \n\
6128  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6129  be in the same units as used by the Shapefile. You could use a\n\
6130  very large negative number to plot everything, but you can improve\n\
6131  performance by limiting the area drawn. The units must match those\n\
6132  of the Shapefile projection, which may be for example longitude or\n\
6133  distance. The value of minx must be less than the value of maxx.\n\
6134 \n\
6135  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6136  use a very large number to plot everything, but you can improve\n\
6137  performance by limiting the area drawn.\n\
6138 \n\
6139  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6140  be in the same units as used by the Shapefile. You could use a\n\
6141  very large negative number to plot everything, but you can improve\n\
6142  performance by limiting the area drawn. The units must match those\n\
6143  of the Shapefile projection, which may be for example latitude or\n\
6144  distance. The value of miny must be less than the value of maxy.\n\
6145 \n\
6146  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6147  use a very large number to plot everything, but you can improve\n\
6148  performance by limiting the area drawn.\n\
6149 \n\
6150  plotentry (PLINT, input) : An integer indicating which text string\n\
6151  of the Shapefile (zero indexed) will be drawn.\n\
6152 ";
6153 static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
6154 Draw a line between two points\n\
6155 \n\
6156 DESCRIPTION:\n\
6157 \n\
6158  Joins the point (\n\
6159  x1,\n\
6160  y1) to (\n\
6161  x2,\n\
6162  y2).\n\
6163 \n\
6164  Redacted form: pljoin(x1,y1,x2,y2)\n\
6165 \n\
6166  This function is used in examples 3 and 14.\n\
6167 \n\
6168 \n\
6169 \n\
6170 SYNOPSIS:\n\
6171 \n\
6172 pljoin(x1, y1, x2, y2)\n\
6173 \n\
6174 ARGUMENTS:\n\
6175 \n\
6176  x1 (PLFLT, input) : x coordinate of first point.\n\
6177 \n\
6178  y1 (PLFLT, input) : y coordinate of first point.\n\
6179 \n\
6180  x2 (PLFLT, input) : x coordinate of second point.\n\
6181 \n\
6182  y2 (PLFLT, input) : y coordinate of second point.\n\
6183 ";
6184 static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6185 Set color, cmap1\n\
6186 \n\
6187 DESCRIPTION:\n\
6188 \n\
6189  Sets the color for cmap1 (see the PLplot documentation).\n\
6190 \n\
6191  Redacted form: plcol1(col1)\n\
6192 \n\
6193  This function is used in examples 12 and 21.\n\
6194 \n\
6195 \n\
6196 \n\
6197 SYNOPSIS:\n\
6198 \n\
6199 plcol1(col1)\n\
6200 \n\
6201 ARGUMENTS:\n\
6202 \n\
6203  col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6204  is mapped to color using the continuous cmap1 palette which by\n\
6205  default ranges from blue to the background color to red. The\n\
6206  cmap1 palette can also be straightforwardly changed by the user\n\
6207  with plscmap1 or plscmap1l.\n\
6208 ";
6209 static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
6210 Set orientation\n\
6211 \n\
6212 DESCRIPTION:\n\
6213 \n\
6214  Set integer plot orientation parameter. This function is identical to\n\
6215  plsdiori except for the type of the argument, and should be used in\n\
6216  the same way. See the documentation of plsdiori for details.\n\
6217 \n\
6218  Redacted form: plsori(ori)\n\
6219 \n\
6220  This function is used in example 3.\n\
6221 \n\
6222 \n\
6223 \n\
6224 SYNOPSIS:\n\
6225 \n\
6226 plsori(ori)\n\
6227 \n\
6228 ARGUMENTS:\n\
6229 \n\
6230  ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
6231  portrait, etc.) The value is multiplied by 90 degrees to get the\n\
6232  angle.\n\
6233 ";
6234 static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6235 Calculate continuous time from broken-down time for the current stream\n\
6236 \n\
6237 DESCRIPTION:\n\
6238 \n\
6239  Calculate continuous time, ctime, from broken-down time for the\n\
6240  current stream. The broken-down\n\
6241  time is specified by the following parameters: year, month, day, hour,\n\
6242  min, and sec. This function is the inverse of plbtime.\n\
6243 \n\
6244  The PLplot definition of broken-down time is a calendar time that\n\
6245  completely ignores all time zone offsets, i.e., it is the user\'s\n\
6246  responsibility to apply those offsets (if so desired) before using the\n\
6247  PLplot time API. By default broken-down time is defined using the\n\
6248  proleptic Gregorian calendar without the insertion of leap seconds and\n\
6249  continuous time is defined as the number of seconds since the Unix\n\
6250  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6251  broken-down and continuous time are possible, see plconfigtime which\n\
6252  specifies that transformation for the current stream.\n\
6253 \n\
6254  Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6255  ctime)\n\
6256 \n\
6257 \n\
6258  This function is used in example 29.\n\
6259 \n\
6260 \n\
6261 \n\
6262 SYNOPSIS:\n\
6263 \n\
6264 plctime(year, month, day, hour, min, sec, ctime)\n\
6265 \n\
6266 ARGUMENTS:\n\
6267 \n\
6268  year (PLINT, input) : Input year.\n\
6269 \n\
6270  month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6271  (December).\n\
6272 \n\
6273  day (PLINT, input) : Input day in range from 1 to 31.\n\
6274 \n\
6275  hour (PLINT, input) : Input hour in range from 0 to 23\n\
6276 \n\
6277  min (PLINT, input) : Input minute in range from 0 to 59.\n\
6278 \n\
6279  sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6280 \n\
6281  ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6282  time calculated from the broken-down time specified by the\n\
6283  previous parameters.\n\
6284 ";
6285 static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
6286 Plot continental outline or shapefile data in world coordinates\n\
6287 \n\
6288 DESCRIPTION:\n\
6289 \n\
6290  Plots continental outlines or shapefile data in world coordinates. A\n\
6291  demonstration of how to use this function to create different\n\
6292  projections can be found in examples/c/x19c. PLplot is provided with\n\
6293  basic coastal outlines and USA state borders. To use the map\n\
6294  functionality PLplot must be compiled with the shapelib library.\n\
6295  Shapefiles have become a popular standard for geographical data and\n\
6296  data in this format can be easily found from a number of online\n\
6297  sources. Shapefile data is actually provided as three or more files\n\
6298  with the same filename, but different extensions. The .shp and .shx\n\
6299  files are required for plotting Shapefile data with PLplot.\n\
6300 \n\
6301  PLplot currently supports the point, multipoint, polyline and polygon\n\
6302  objects within shapefiles. However holes in polygons are not\n\
6303  supported. When plmap is used the type of object is derived from the\n\
6304  shapefile, if you wish to override the type then use one of the other\n\
6305  plmap variants. The built in maps have line data only.\n\
6306 \n\
6307  Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
6308 \n\
6309  This function is used in example 19.\n\
6310 \n\
6311 \n\
6312 \n\
6313 SYNOPSIS:\n\
6314 \n\
6315 plmap(mapform, name, minx, maxx, miny, maxy)\n\
6316 \n\
6317 ARGUMENTS:\n\
6318 \n\
6319  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6320  transform the original map data coordinates to a new coordinate\n\
6321  system. The PLplot-supplied map data is provided as latitudes and\n\
6322  longitudes; other Shapefile data may be provided in other\n\
6323  coordinate systems as can be found in their .prj plain text files.\n\
6324  For example, by using this transform we can change from a\n\
6325  longitude, latitude coordinate to a polar stereographic\n\
6326  projection. Initially, x[0]..[n-1] are the original x coordinates\n\
6327  (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
6328  corresponding y coordinates (latitudes for the PLplot supplied\n\
6329  data). After the call to mapform(), x[] and y[] should be\n\
6330  replaced by the corresponding plot coordinates. If no transform is\n\
6331  desired, mapform can be replaced by NULL.\n\
6332 \n\
6333  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6334  the type of map plotted. This is either one of the PLplot built-in\n\
6335  maps or the file name of a set of Shapefile files without the file\n\
6336  extensions. For the PLplot built-in maps the possible values are:\n\
6337  \"globe\" -- continental outlines\n\
6338  \"usa\" -- USA and state boundaries\n\
6339  \"cglobe\" -- continental outlines and countries\n\
6340  \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6341 \n\
6342 \n\
6343  minx (PLFLT, input) : The minimum x value of map elements to be\n\
6344  drawn. The units must match the shapefile (built in maps are\n\
6345  degrees lat/lon). Objects in the file which do not encroach on the\n\
6346  box defined by minx, maxx, miny, maxy will not be rendered. But\n\
6347  note this is simply an optimisation, not a clipping so for objects\n\
6348  with some points inside the box and some points outside the box\n\
6349  all the points will be rendered. These parameters also define\n\
6350  latitude and longitude wrapping for shapefiles using these units.\n\
6351  Longitude points will be wrapped by integer multiples of 360\n\
6352  degrees to place them in the box. This allows the same data to be\n\
6353  used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
6354  you plot from -180-540 you will get two cycles of data drawn. The\n\
6355  value of minx must be less than the value of maxx. Passing in a\n\
6356  nan, max/-max floating point number or +/-infinity will case the\n\
6357  bounding box from the shapefile to be used.\n\
6358 \n\
6359  maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6360  drawn - see minx.\n\
6361 \n\
6362  miny (PLFLT, input) : The minimum y value of map elements to be\n\
6363  drawn - see minx.\n\
6364 \n\
6365  maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6366  drawn - see minx.\n\
6367 ";
6368 static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
6369 Calculate broken-down time from continuous time for the current stream\n\
6370 \n\
6371 DESCRIPTION:\n\
6372 \n\
6373  Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6374  continuous time, ctime for the current stream. This function is the\n\
6375  inverse of plctime.\n\
6376 \n\
6377  The PLplot definition of broken-down time is a calendar time that\n\
6378  completely ignores all time zone offsets, i.e., it is the user\'s\n\
6379  responsibility to apply those offsets (if so desired) before using the\n\
6380  PLplot time API. By default broken-down time is defined using the\n\
6381  proleptic Gregorian calendar without the insertion of leap seconds and\n\
6382  continuous time is defined as the number of seconds since the Unix\n\
6383  epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6384  broken-down and continuous time are possible, see plconfigtime.\n\
6385 \n\
6386  Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6387  ctime)\n\
6388 \n\
6389 \n\
6390  This function is used in example 29.\n\
6391 \n\
6392 \n\
6393 \n\
6394 SYNOPSIS:\n\
6395 \n\
6396 plbtime(year, month, day, hour, min, sec, ctime)\n\
6397 \n\
6398 ARGUMENTS:\n\
6399 \n\
6400  year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6401  positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6402  non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6403  BCE, etc.)\n\
6404 \n\
6405  month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6406  the year in the range from 0 (January) to 11 (December).\n\
6407 \n\
6408  day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6409  month in the range from 1 to 31.\n\
6410 \n\
6411  hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6412  day in the range from 0 to 23.\n\
6413 \n\
6414  min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6415  hour in the range from 0 to 59\n\
6416 \n\
6417  sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6418  minute in range from 0. to 60.\n\
6419 \n\
6420  ctime (PLFLT, input) : Continuous time from which the broken-down\n\
6421  time is calculated.\n\
6422 ";
6423 static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
6424 Get current stream number\n\
6425 \n\
6426 DESCRIPTION:\n\
6427 \n\
6428  Gets the number of the current output stream. See also plsstrm.\n\
6429 \n\
6430  Redacted form: plgstrm(p_strm)\n\
6431 \n\
6432  This function is used in example 1,20.\n\
6433 \n\
6434 \n\
6435 \n\
6436 SYNOPSIS:\n\
6437 \n\
6438 plgstrm(p_strm)\n\
6439 \n\
6440 ARGUMENTS:\n\
6441 \n\
6442  p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6443  stream value.\n\
6444 ";
6445 static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
6446 Draw a line in 3 space\n\
6447 \n\
6448 DESCRIPTION:\n\
6449 \n\
6450  Draws line in 3 space defined by n points in x, y, and z. You must\n\
6451  first set up the viewport, the 2d viewing window (in world\n\
6452  coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6453  more info.\n\
6454 \n\
6455  Redacted form: plline3(x, y, z)\n\
6456 \n\
6457  This function is used in example 18.\n\
6458 \n\
6459 \n\
6460 \n\
6461 SYNOPSIS:\n\
6462 \n\
6463 plline3(n, x, y, z)\n\
6464 \n\
6465 ARGUMENTS:\n\
6466 \n\
6467  n (PLINT, input) : Number of points defining line.\n\
6468 \n\
6469  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6470  points.\n\
6471 \n\
6472  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6473  points.\n\
6474 \n\
6475  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6476  points.\n\
6477 ";
6478 static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
6479 Load Hershey fonts\n\
6480 \n\
6481 DESCRIPTION:\n\
6482 \n\
6483  Loads the Hershey fonts used for text and symbols. This routine may\n\
6484  be called before or after initializing PLplot. If not explicitly\n\
6485  called before PLplot initialization, then by default that\n\
6486  initialization loads Hershey fonts with the extended character set.\n\
6487  This routine only has a practical effect for devices that still use\n\
6488  Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6489  system fonts instead of Hershey fonts).\n\
6490 \n\
6491  Redacted form: plfontld(fnt)\n\
6492 \n\
6493  This function is used in examples 1 and 7.\n\
6494 \n\
6495 \n\
6496 \n\
6497 SYNOPSIS:\n\
6498 \n\
6499 plfontld(fnt)\n\
6500 \n\
6501 ARGUMENTS:\n\
6502 \n\
6503  fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6504  A zero value specifies Hershey fonts with the standard character\n\
6505  set and a non-zero value (the default assumed if plfontld is never\n\
6506  called) specifies Hershey fonts with the extended character set.\n\
6507 ";
6508 static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
6509 Set any command-line option\n\
6510 \n\
6511 DESCRIPTION:\n\
6512 \n\
6513  Set any command-line option internally from a program before it\n\
6514  invokes plinit. opt is the name of the command-line option and optarg\n\
6515  is the corresponding command-line option argument.\n\
6516 \n\
6517  This function returns 0 on success.\n\
6518 \n\
6519  Redacted form: plsetopt(opt, optarg)\n\
6520 \n\
6521  This function is used in example 14.\n\
6522 \n\
6523 \n\
6524 \n\
6525 SYNOPSIS:\n\
6526 \n\
6527 PLINT plsetopt(opt, optarg)\n\
6528 \n\
6529 ARGUMENTS:\n\
6530 \n\
6531  opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6532  the command-line option.\n\
6533 \n\
6534  optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6535  containing the argument of the command-line option.\n\
6536 ";
6537 static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
6538 Plot all or a subset of Shapefile data using lines in world coordinates\n\
6539 \n\
6540 DESCRIPTION:\n\
6541 \n\
6542  Plot all or a subset of Shapefile data using lines in world\n\
6543  coordinates. Our 19th standard example demonstrates how to use this\n\
6544  function. This function plots data from a Shapefile using lines as in\n\
6545  plmap, however it also has the option of also only drawing specified\n\
6546  elements from the Shapefile. The vector of indices of the required\n\
6547  elements are passed as a function argument. The Shapefile data should\n\
6548  include a metadata file (extension.dbf) listing all items within the\n\
6549  Shapefile. This file can be opened by most popular spreadsheet\n\
6550  programs and can be used to decide which indices to pass to this\n\
6551  function.\n\
6552 \n\
6553  Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6554  plotentries)\n\
6555 \n\
6556  This function is used in example 19.\n\
6557 \n\
6558 \n\
6559 \n\
6560 SYNOPSIS:\n\
6561 \n\
6562 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6563 \n\
6564 ARGUMENTS:\n\
6565 \n\
6566  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6567  transform the coordinates given in the shapefile into a plot\n\
6568  coordinate system. By using this transform, we can change from a\n\
6569  longitude, latitude coordinate to a polar stereographic project,\n\
6570  for example. Initially, x[0]..[n-1] are the longitudes and\n\
6571  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6572  mapform(), x[] and y[] should be replaced by the corresponding\n\
6573  plot coordinates. If no transform is desired, mapform can be\n\
6574  replaced by NULL.\n\
6575 \n\
6576  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6577  the file name of a set of Shapefile files without the file\n\
6578  extension.\n\
6579 \n\
6580  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6581  be in the same units as used by the Shapefile. You could use a\n\
6582  very large negative number to plot everything, but you can improve\n\
6583  performance by limiting the area drawn. The units must match those\n\
6584  of the Shapefile projection, which may be for example longitude or\n\
6585  distance. The value of minx must be less than the value of maxx.\n\
6586 \n\
6587  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6588  use a very large number to plot everything, but you can improve\n\
6589  performance by limiting the area drawn.\n\
6590 \n\
6591  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6592  be in the same units as used by the Shapefile. You could use a\n\
6593  very large negative number to plot everything, but you can improve\n\
6594  performance by limiting the area drawn. The units must match those\n\
6595  of the Shapefile projection, which may be for example latitude or\n\
6596  distance. The value of miny must be less than the value of maxy.\n\
6597 \n\
6598  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6599  use a very large number to plot everything, but you can improve\n\
6600  performance by limiting the area drawn.\n\
6601 \n\
6602  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6603  zero-based indices of the Shapefile elements which will be drawn.\n\
6604  Setting\n\
6605  plotentries to NULL will plot all elements of the Shapefile.\n\
6606 \n\
6607  nplotentries (PLINT, input) : The number of items in\n\
6608  plotentries. Ignored if\n\
6609  plotentries is NULL.\n\
6610 ";
6611 static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6612 Used to globally turn color output on/off\n\
6613 \n\
6614 DESCRIPTION:\n\
6615 \n\
6616  Used to globally turn color output on/off for those drivers/devices\n\
6617  that support it.\n\
6618 \n\
6619  Redacted form: plscolor(color)\n\
6620 \n\
6621  This function is used in example 31.\n\
6622 \n\
6623 \n\
6624 \n\
6625 SYNOPSIS:\n\
6626 \n\
6627 plscolor(color)\n\
6628 \n\
6629 ARGUMENTS:\n\
6630 \n\
6631  color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6632  turned off. If non-zero, color is turned on.\n\
6633 ";
6634 static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
6635 Wait for graphics input event and translate to world coordinates.\n\
6636 \n\
6637 DESCRIPTION:\n\
6638 \n\
6639  Wait for graphics input event and translate to world coordinates.\n\
6640  Returns 0 if no translation to world coordinates is possible.\n\
6641 \n\
6642  This function returns 1 on success and 0 if no translation to world\n\
6643  coordinates is possible.\n\
6644 \n\
6645  Redacted form: plGetCursor(gin)\n\
6646 \n\
6647  This function is used in examples 1 and 20.\n\
6648 \n\
6649 \n\
6650 \n\
6651 SYNOPSIS:\n\
6652 \n\
6653 PLINT plGetCursor(gin)\n\
6654 \n\
6655 ARGUMENTS:\n\
6656 \n\
6657  gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6658  which will contain the output. The structure is not allocated by\n\
6659  the routine and must exist before the function is called.\n\
6660 ";
6661 static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
6662 Get the current device (keyword) name\n\
6663 \n\
6664 DESCRIPTION:\n\
6665 \n\
6666  Get the current device (keyword) name. Note: you must have allocated\n\
6667  space for this (80 characters is safe).\n\
6668 \n\
6669  Redacted form: plgdev(p_dev)\n\
6670 \n\
6671  This function is used in example 14.\n\
6672 \n\
6673 \n\
6674 \n\
6675 SYNOPSIS:\n\
6676 \n\
6677 plgdev(p_dev)\n\
6678 \n\
6679 ARGUMENTS:\n\
6680 \n\
6681  p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6682  (with preallocated length of 80 characters or more) containing the\n\
6683  device (keyword) name.\n\
6684 ";
6685 static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
6686 Add a point to a strip chart\n\
6687 \n\
6688 DESCRIPTION:\n\
6689 \n\
6690  Add a point to a given pen of a given strip chart. There is no need\n\
6691  for all pens to have the same number of points or to be equally\n\
6692  sampled in the x coordinate. Allocates memory and rescales as\n\
6693  necessary.\n\
6694 \n\
6695  Redacted form: plstripa(id, pen, x, y)\n\
6696 \n\
6697  This function is used in example 17.\n\
6698 \n\
6699 \n\
6700 \n\
6701 SYNOPSIS:\n\
6702 \n\
6703 plstripa(id, pen, x, y)\n\
6704 \n\
6705 ARGUMENTS:\n\
6706 \n\
6707  id (PLINT, input) : Identification number of the strip chart (set\n\
6708  up in plstripc).\n\
6709 \n\
6710  pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6711 \n\
6712  x (PLFLT, input) : X coordinate of point to plot.\n\
6713 \n\
6714  y (PLFLT, input) : Y coordinate of point to plot.\n\
6715 ";
6716 static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
6717 Create a 4-pen strip chart\n\
6718 \n\
6719 DESCRIPTION:\n\
6720 \n\
6721  Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6722 \n\
6723  Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6724  ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6725  styline, legline, labx, laby, labz)\n\
6726 \n\
6727 \n\
6728  This function is used in example 17.\n\
6729 \n\
6730 \n\
6731 \n\
6732 SYNOPSIS:\n\
6733 \n\
6734 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6735 \n\
6736 ARGUMENTS:\n\
6737 \n\
6738  id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6739  number of the strip chart to use on plstripa and plstripd.\n\
6740 \n\
6741  xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6742  the x-axis specification as in plbox.\n\
6743 \n\
6744  yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6745  the y-axis specification as in plbox.\n\
6746 \n\
6747  xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6748  change as data are added.\n\
6749 \n\
6750  xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6751  change as data are added.\n\
6752 \n\
6753  xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6754  is multiplied by the factor (1 +\n\
6755  xjump) .\n\
6756 \n\
6757  ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6758  change as data are added.\n\
6759 \n\
6760  ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6761  change as data are added.\n\
6762 \n\
6763  xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6764 \n\
6765  ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6766 \n\
6767  y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6768  true, otherwise not.\n\
6769 \n\
6770  acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6771  otherwise slide display.\n\
6772 \n\
6773  colbox (PLINT, input) : Plot box color index (cmap0).\n\
6774 \n\
6775  collab (PLINT, input) : Legend color index (cmap0).\n\
6776 \n\
6777  colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6778  indices for the 4 pens.\n\
6779 \n\
6780  styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6781  indices for the 4 pens.\n\
6782 \n\
6783  legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6784  strings containing legends for the 4 pens.\n\
6785 \n\
6786  labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6787  the label for the x axis.\n\
6788 \n\
6789  laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6790  the label for the y axis.\n\
6791 \n\
6792  labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6793  the plot title.\n\
6794 ";
6795 static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
6796 Deletes and releases memory used by a strip chart\n\
6797 \n\
6798 DESCRIPTION:\n\
6799 \n\
6800  Deletes and releases memory used by a strip chart.\n\
6801 \n\
6802  Redacted form: plstripd(id)\n\
6803 \n\
6804  This function is used in example 17.\n\
6805 \n\
6806 \n\
6807 \n\
6808 SYNOPSIS:\n\
6809 \n\
6810 plstripd(id)\n\
6811 \n\
6812 ARGUMENTS:\n\
6813 \n\
6814  id (PLINT, input) : Identification number of strip chart to delete.\n\
6815 ";
6816 static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
6817 Specify viewport using coordinates and aspect ratio\n\
6818 \n\
6819 DESCRIPTION:\n\
6820 \n\
6821  Device-independent routine for setting up the viewport. The viewport\n\
6822  is chosen to be the largest with the given aspect ratio that fits\n\
6823  within the specified region (in terms of normalized subpage\n\
6824  coordinates). This routine is functionally equivalent to plvpor when\n\
6825  a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6826  routine reserves no extra space at the edges for labels.\n\
6827 \n\
6828  Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6829 \n\
6830  This function is used in example 9.\n\
6831 \n\
6832 \n\
6833 \n\
6834 SYNOPSIS:\n\
6835 \n\
6836 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6837 \n\
6838 ARGUMENTS:\n\
6839 \n\
6840  xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6841  left-hand edge of the viewport.\n\
6842 \n\
6843  xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6844  right-hand edge of the viewport.\n\
6845 \n\
6846  ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6847  bottom edge of the viewport.\n\
6848 \n\
6849  ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6850  edge of the viewport.\n\
6851 \n\
6852  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6853  axis.\n\
6854 ";
6855 static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
6856 Assign a function to use for generating custom axis labels\n\
6857 \n\
6858 DESCRIPTION:\n\
6859 \n\
6860  This function allows a user to provide their own function to provide\n\
6861  axis label text. The user function is given the numeric value for a\n\
6862  point on an axis and returns a string label to correspond with that\n\
6863  value. Custom axis labels can be enabled by passing appropriate\n\
6864  arguments to plenv, plbox, plbox3 and similar functions.\n\
6865 \n\
6866  This function is used in example 19.\n\
6867 \n\
6868 \n\
6869 \n\
6870 SYNOPSIS:\n\
6871 \n\
6872 plslabelfunc(label_func, label_data)\n\
6873 \n\
6874 ARGUMENTS:\n\
6875 \n\
6876  label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6877  label function. In order to reset to the default labelling, set\n\
6878  this to NULL. The labelling function parameters are, in order:\n\
6879  axis: This indicates which axis a label is being requested for.\n\
6880  The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6881 \n\
6882  value: This is the value along the axis which is being labelled.\n\
6883 \n\
6884  label_text: The string representation of the label value.\n\
6885 \n\
6886  length: The maximum length in characters allowed for label_text.\n\
6887 \n\
6888 \n\
6889  label_data (PLPointer, input) : This parameter may be used to pass\n\
6890  data to the label_func function.\n\
6891 ";
6892 static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
6893 Set length of major ticks\n\
6894 \n\
6895 DESCRIPTION:\n\
6896 \n\
6897  This sets up the length of the major ticks. The actual length is the\n\
6898  product of the default length and a scaling factor as for character\n\
6899  height.\n\
6900 \n\
6901  Redacted form: plsmaj(def, scale)\n\
6902 \n\
6903  This function is used in example 29.\n\
6904 \n\
6905 \n\
6906 \n\
6907 SYNOPSIS:\n\
6908 \n\
6909 plsmaj(def, scale)\n\
6910 \n\
6911 ARGUMENTS:\n\
6912 \n\
6913  def (PLFLT, input) : The default length of a major tick in\n\
6914  millimeters, should be set to zero if the default length is to\n\
6915  remain unchanged.\n\
6916 \n\
6917  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6918  actual tick length.\n\
6919 ";
6920 static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
6921 Get the current library version number\n\
6922 \n\
6923 DESCRIPTION:\n\
6924 \n\
6925  Get the current library version number. Note: you must have allocated\n\
6926  space for this (80 characters is safe).\n\
6927 \n\
6928  Redacted form: plgver(p_ver)\n\
6929 \n\
6930  This function is used in example 1.\n\
6931 \n\
6932 \n\
6933 \n\
6934 SYNOPSIS:\n\
6935 \n\
6936 plgver(p_ver)\n\
6937 \n\
6938 ARGUMENTS:\n\
6939 \n\
6940  p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6941  (with preallocated length of 80 characters or more) containing the\n\
6942  PLplot version number.\n\
6943 ";
6944 static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
6945 Set format of numerical label for contours\n\
6946 \n\
6947 DESCRIPTION:\n\
6948 \n\
6949  Set format of numerical label for contours.\n\
6950 \n\
6951  Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
6952 \n\
6953  This function is used example 9.\n\
6954 \n\
6955 \n\
6956 \n\
6957 SYNOPSIS:\n\
6958 \n\
6959 pl_setcontlabelformat(lexp, sigdig)\n\
6960 \n\
6961 ARGUMENTS:\n\
6962 \n\
6963  lexp (PLINT, input) : If the contour numerical label is greater\n\
6964  than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
6965  format is used. Default value of lexp is 4.\n\
6966 \n\
6967  sigdig (PLINT, input) : Number of significant digits. Default\n\
6968  value is 2.\n\
6969 ";
6970 static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6971 Parse command-line arguments\n\
6972 \n\
6973 DESCRIPTION:\n\
6974 \n\
6975  Parse command-line arguments.\n\
6976 \n\
6977  plparseopts removes all recognized flags (decreasing argc\n\
6978  accordingly), so that invalid input may be readily detected. It can\n\
6979  also be used to process user command line flags. The user can merge\n\
6980  an option table of type PLOptionTable into the internal option table\n\
6981  info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6982  the external table(s) be parsed by calling plClearOpts before\n\
6983  plMergeOpts.\n\
6984 \n\
6985  The default action taken by plparseopts is as follows:\n\
6986  Returns with an error if an unrecognized option or badly formed\n\
6987  option-value pair are encountered.\n\
6988  Returns immediately (return code 0) when the first non-option command\n\
6989  line argument is found.\n\
6990  Returns with the return code of the option handler, if one was called.\n\
6991 \n\
6992  Deletes command line arguments from argv list as they are found, and\n\
6993  decrements argc accordingly.\n\
6994  Does not show \"invisible\" options in usage or help messages.\n\
6995  Assumes the program name is contained in argv[0].\n\
6996 \n\
6997  These behaviors may be controlled through the\n\
6998  mode argument.\n\
6999 \n\
7000  Redacted form: General: plparseopts(argv, mode)\n\
7001 \n\
7002 \n\
7003  This function is used in all of the examples.\n\
7004 \n\
7005 \n\
7006 \n\
7007 SYNOPSIS:\n\
7008 \n\
7009 PLINT plparseopts(p_argc, argv, mode)\n\
7010 \n\
7011 ARGUMENTS:\n\
7012 \n\
7013  p_argc (int *, input/output) : Number of arguments.\n\
7014 \n\
7015  argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7016  strings containing *p_argc command-line arguments.\n\
7017 \n\
7018  mode (PLINT, input) : Parsing mode with the following\n\
7019  possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7020  and all error messages enabled, including program exit when an\n\
7021  error occurs. Anything on the command line that isn\'t recognized\n\
7022  as a valid option or option argument is flagged as an error.\n\
7023  PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7024  of errors.\n\
7025  PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7026  arguments.\n\
7027  PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7028  PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7029  pointer to the program name.\n\
7030  PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7031  PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7032  unrecognized arguments.\n\
7033 ";
7034 static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
7035 Initialization\n\
7036 \n\
7037 DESCRIPTION:\n\
7038 \n\
7039  Initializing the plotting package. The program prompts for the device\n\
7040  keyword or number of the desired output device. Hitting a RETURN in\n\
7041  response to the prompt is the same as selecting the first device. If\n\
7042  only one device is enabled when PLplot is installed, plstar will issue\n\
7043  no prompt. The output device is divided into nx by ny subpages, each\n\
7044  of which may be used independently. The subroutine pladv is used to\n\
7045  advance from one subpage to the next.\n\
7046 \n\
7047  Redacted form: plstar(nx, ny)\n\
7048 \n\
7049  This function is used in example 1.\n\
7050 \n\
7051 \n\
7052 \n\
7053 SYNOPSIS:\n\
7054 \n\
7055 plstar(nx, ny)\n\
7056 \n\
7057 ARGUMENTS:\n\
7058 \n\
7059  nx (PLINT, input) : Number of subpages to divide output page in the\n\
7060  x direction.\n\
7061 \n\
7062  ny (PLINT, input) : Number of subpages to divide output page in the\n\
7063  y direction.\n\
7064 ";
7065 static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
7066 Get FCI (font characterization integer)\n\
7067 \n\
7068 DESCRIPTION:\n\
7069 \n\
7070  Gets information about the current font using the FCI approach. See\n\
7071  the PLplot documentation for more information.\n\
7072 \n\
7073  Redacted form: plgfci(p_fci)\n\
7074 \n\
7075  This function is used in example 23.\n\
7076 \n\
7077 \n\
7078 \n\
7079 SYNOPSIS:\n\
7080 \n\
7081 plgfci(p_fci)\n\
7082 \n\
7083 ARGUMENTS:\n\
7084 \n\
7085  p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
7086  FCI value.\n\
7087 ";
7088 static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
7089 Set family file parameters\n\
7090 \n\
7091 DESCRIPTION:\n\
7092 \n\
7093  Sets variables dealing with output file familying. Does nothing if\n\
7094  familying not supported by the driver. This routine, if used, must be\n\
7095  called before initializing PLplot. See the PLplot documentation for\n\
7096  more information.\n\
7097 \n\
7098  Redacted form: plsfam(fam, num, bmax)\n\
7099 \n\
7100  This function is used in examples 14 and 31.\n\
7101 \n\
7102 \n\
7103 \n\
7104 SYNOPSIS:\n\
7105 \n\
7106 plsfam(fam, num, bmax)\n\
7107 \n\
7108 ARGUMENTS:\n\
7109 \n\
7110  fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
7111  is enabled.\n\
7112 \n\
7113  num (PLINT, input) : Current family file number.\n\
7114 \n\
7115  bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
7116  file.\n\
7117 ";
7118 static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
7119 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
7120 \n\
7121 DESCRIPTION:\n\
7122 \n\
7123  This is a variant of plscmap1l that supports alpha channel\n\
7124  transparency. It sets cmap1 colors using a piece-wise linear\n\
7125  relationship between cmap1 intensity index (0.0-1.0) and position in\n\
7126  HLS or RGB color space (see the PLplot documentation) with alpha\n\
7127  transparency value (0.0-1.0). It may be called at any time.\n\
7128 \n\
7129  Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
7130  alpha, alt_hue_path)\n\
7131 \n\
7132  This function is used in example 30.\n\
7133 \n\
7134 \n\
7135 \n\
7136 SYNOPSIS:\n\
7137 \n\
7138 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
7139 \n\
7140 ARGUMENTS:\n\
7141 \n\
7142  itype (PLBOOL, input) : true: RGB, false: HLS.\n\
7143 \n\
7144  npts (PLINT, input) : number of control points.\n\
7145 \n\
7146  intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
7147  intensity index (0.0-1.0) in ascending order for each control\n\
7148  point.\n\
7149 \n\
7150  coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
7151  coordinate (H or R) for each control point.\n\
7152 \n\
7153  coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
7154  coordinate (L or G) for each control point.\n\
7155 \n\
7156  coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
7157  coordinate (S or B) for each control point.\n\
7158 \n\
7159  alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
7160  transparency value (0.0-1.0) for each control point.\n\
7161 \n\
7162  alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
7163  npts - 1 elements) containing the alternative interpolation method\n\
7164  Boolean value for each control point interval. (alt_hue_path[i]\n\
7165  refers to the interpolation interval between the i and i + 1\n\
7166  control points).\n\
7167 ";
7168 static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
7169 Set page parameters\n\
7170 \n\
7171 DESCRIPTION:\n\
7172 \n\
7173  Sets the page configuration (optional). If an individual parameter is\n\
7174  zero then that parameter value is not updated. Not all parameters are\n\
7175  recognized by all drivers and the interpretation is device-dependent.\n\
7176  The X-window driver uses the length and offset parameters to determine\n\
7177  the window size and location. The length and offset values are\n\
7178  expressed in units that are specific to the current driver. For\n\
7179  instance: screen drivers will usually interpret them as number of\n\
7180  pixels, whereas printer drivers will usually use mm.\n\
7181 \n\
7182  This routine, if used, must be called before initializing PLplot. It\n\
7183  may be called at later times for interactive drivers to change only\n\
7184  the dpi for subsequent redraws which you can force via a call to\n\
7185  plreplot. If this function is not called then the page size defaults\n\
7186  to landscape A4 for drivers which use real world page sizes and 744\n\
7187  pixels wide by 538 pixels high for raster drivers. The default value\n\
7188  for dx and dy is 90 pixels per inch for raster drivers.\n\
7189 \n\
7190 \n\
7191 \n\
7192  Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7193 \n\
7194  This function is used in examples 14 and 31.\n\
7195 \n\
7196 \n\
7197 \n\
7198 SYNOPSIS:\n\
7199 \n\
7200 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7201 \n\
7202 ARGUMENTS:\n\
7203 \n\
7204  xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
7205  by raster drivers, ignored by drivers which use \"real world\" units\n\
7206  (e.g. mm).\n\
7207 \n\
7208  yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
7209  by raster drivers, ignored by drivers which use \"real world\" units\n\
7210  (e.g. mm).\n\
7211 \n\
7212  xleng (PLINT, input) : Page length, x.\n\
7213 \n\
7214  yleng (PLINT, input) : Page length, y.\n\
7215 \n\
7216  xoff (PLINT, input) : Page offset, x.\n\
7217 \n\
7218  yoff (PLINT, input) : Page offset, y.\n\
7219 ";
7220 static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7221 Set precision in numeric labels\n\
7222 \n\
7223 DESCRIPTION:\n\
7224 \n\
7225  Sets the number of places after the decimal point in numeric labels.\n\
7226 \n\
7227  Redacted form: plprec(setp, prec)\n\
7228 \n\
7229  This function is used in example 29.\n\
7230 \n\
7231 \n\
7232 \n\
7233 SYNOPSIS:\n\
7234 \n\
7235 plprec(setp, prec)\n\
7236 \n\
7237 ARGUMENTS:\n\
7238 \n\
7239  setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7240  automatically determines the number of places to use after the\n\
7241  decimal point in numeric labels (like those used to label axes).\n\
7242  If setp is 1 then prec sets the number of places.\n\
7243 \n\
7244  prec (PLINT, input) : The number of characters to draw after the\n\
7245  decimal point in numeric labels.\n\
7246 ";
7247 static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
7248 Copy state parameters from the reference stream to the current stream\n\
7249 \n\
7250 DESCRIPTION:\n\
7251 \n\
7252  Copies state parameters from the reference stream to the current\n\
7253  stream. Tell driver interface to map device coordinates unless flags\n\
7254  == 1.\n\
7255 \n\
7256  This function is used for making save files of selected plots (e.g.\n\
7257  from the TK driver). After initializing, you can get a copy of the\n\
7258  current plot to the specified device by switching to this stream and\n\
7259  issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
7260  appropriate. The plot buffer must have previously been enabled (done\n\
7261  automatically by some display drivers, such as X).\n\
7262 \n\
7263  Redacted form: plcpstrm(iplsr, flags)\n\
7264 \n\
7265  This function is used in example 1,20.\n\
7266 \n\
7267 \n\
7268 \n\
7269 SYNOPSIS:\n\
7270 \n\
7271 plcpstrm(iplsr, flags)\n\
7272 \n\
7273 ARGUMENTS:\n\
7274 \n\
7275  iplsr (PLINT, input) : Number of reference stream.\n\
7276 \n\
7277  flags (PLBOOL, input) : If flags is set to true the device\n\
7278  coordinates are not copied from the reference to current stream.\n\
7279 ";
7280 static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
7281 Plot a glyph at the specified points\n\
7282 \n\
7283 DESCRIPTION:\n\
7284 \n\
7285  Plot a glyph at the specified points. (This function is largely\n\
7286  superseded by plstring which gives access to many[!] more glyphs.)\n\
7287  code=-1 means try to just draw a point. Right now it\'s just a move\n\
7288  and a draw at the same place. Not ideal, since a sufficiently\n\
7289  intelligent output device may optimize it away, or there may be faster\n\
7290  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7291  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7292  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7293  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7294  code <= 127 the corresponding printable ASCII character is plotted.\n\
7295 \n\
7296  Redacted form: plpoin(x, y, code)\n\
7297 \n\
7298  This function is used in examples 1, 6, 14, and 29.\n\
7299 \n\
7300 \n\
7301 \n\
7302 SYNOPSIS:\n\
7303 \n\
7304 plpoin(n, x, y, code)\n\
7305 \n\
7306 ARGUMENTS:\n\
7307 \n\
7308  n (PLINT, input) : Number of points in the x and y vectors.\n\
7309 \n\
7310  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7311  points.\n\
7312 \n\
7313  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7314  points.\n\
7315 \n\
7316  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7317  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7318  each of the n points.\n\
7319 ";
7320 static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
7321 Enter or leave xor mode\n\
7322 \n\
7323 DESCRIPTION:\n\
7324 \n\
7325  Enter (when mode is true) or leave (when mode is false) xor mode for\n\
7326  those drivers (e.g., the xwin driver) that support it. Enables\n\
7327  erasing plots by drawing twice the same line, symbol, etc. If driver\n\
7328  is not capable of xor operation it returns a status of false.\n\
7329 \n\
7330  Redacted form: plxormod(mode, status)\n\
7331 \n\
7332  This function is used in examples 1 and 20.\n\
7333 \n\
7334 \n\
7335 \n\
7336 SYNOPSIS:\n\
7337 \n\
7338 plxormod(mode, status)\n\
7339 \n\
7340 ARGUMENTS:\n\
7341 \n\
7342  mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7343  is false means leave xor mode.\n\
7344 \n\
7345  status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7346  modestatus of true (false) means driver is capable (incapable) of\n\
7347  xor mode.\n\
7348 ";
7349 static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
7350 Get viewport limits in normalized device coordinates\n\
7351 \n\
7352 DESCRIPTION:\n\
7353 \n\
7354  Get viewport limits in normalized device coordinates.\n\
7355 \n\
7356  Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7357 \n\
7358 \n\
7359  This function is used in example 31.\n\
7360 \n\
7361 \n\
7362 \n\
7363 SYNOPSIS:\n\
7364 \n\
7365 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7366 \n\
7367 ARGUMENTS:\n\
7368 \n\
7369  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7370  viewport limit of the normalized device coordinate in x.\n\
7371 \n\
7372  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7373  viewport limit of the normalized device coordinate in x.\n\
7374 \n\
7375  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7376  viewport limit of the normalized device coordinate in y.\n\
7377 \n\
7378  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7379  viewport limit of the normalized device coordinate in y.\n\
7380 ";
7381 static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
7382 Plot surface mesh\n\
7383 \n\
7384 DESCRIPTION:\n\
7385 \n\
7386  Plots a surface mesh within the environment set up by plw3d. The\n\
7387  surface is defined by the matrix z[\n\
7388  nx][\n\
7389  ny] , the point z[i][j] being the value of the function at (\n\
7390  x[i],\n\
7391  y[j]). Note that the points in vectors x and y do not need to be\n\
7392  equally spaced, but must be stored in ascending order. The parameter\n\
7393  opt controls the way in which the surface is displayed. For further\n\
7394  details see the PLplot documentation.\n\
7395 \n\
7396  Redacted form: plmesh(x, y, z, opt)\n\
7397 \n\
7398  This function is used in example 11.\n\
7399 \n\
7400 \n\
7401 \n\
7402 SYNOPSIS:\n\
7403 \n\
7404 plmesh(x, y, z, nx, ny, opt)\n\
7405 \n\
7406 ARGUMENTS:\n\
7407 \n\
7408  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7409  which the function is evaluated.\n\
7410 \n\
7411  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7412  which the function is evaluated.\n\
7413 \n\
7414  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7415  plot. Should have dimensions of\n\
7416  nx by\n\
7417  ny.\n\
7418 \n\
7419  nx (PLINT, input) : Number of x values at which function has been\n\
7420  evaluated.\n\
7421 \n\
7422  ny (PLINT, input) : Number of y values at which function has been\n\
7423  evaluated.\n\
7424 \n\
7425  opt (PLINT, input) : Determines the way in which the surface is\n\
7426  represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7427  function of x for each value of y[j] .\n\
7428  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7429  for each value of x[i] .\n\
7430  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7431  at which function is defined.\n\
7432 ";
7433 static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
7434 Magnitude colored plot surface mesh with contour\n\
7435 \n\
7436 DESCRIPTION:\n\
7437 \n\
7438  A more powerful form of plmesh: the surface mesh can be colored\n\
7439  accordingly to the current z value being plotted, a contour plot can\n\
7440  be drawn at the base XY plane, and a curtain can be drawn between the\n\
7441  plotted function border and the base XY plane.\n\
7442 \n\
7443  Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7444 \n\
7445  This function is used in example 11.\n\
7446 \n\
7447 \n\
7448 \n\
7449 SYNOPSIS:\n\
7450 \n\
7451 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7452 \n\
7453 ARGUMENTS:\n\
7454 \n\
7455  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7456  which the function is evaluated.\n\
7457 \n\
7458  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7459  which the function is evaluated.\n\
7460 \n\
7461  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7462  plot. Should have dimensions of\n\
7463  nx by\n\
7464  ny.\n\
7465 \n\
7466  nx (PLINT, input) : Number of x values at which function is\n\
7467  evaluated.\n\
7468 \n\
7469  ny (PLINT, input) : Number of y values at which function is\n\
7470  evaluated.\n\
7471 \n\
7472  opt (PLINT, input) : Determines the way in which the surface is\n\
7473  represented. To specify more than one option just add the options,\n\
7474  e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7475  showing z as a function of x for each value of y[j] .\n\
7476  opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7477  for each value of x[i] .\n\
7478  opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7479  at which function is defined.\n\
7480  opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7481  the z value being plotted. The color is used from the current\n\
7482  cmap1.\n\
7483  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7484  using parameters\n\
7485  nlevel and\n\
7486  clevel.\n\
7487  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7488  the borders of the plotted function.\n\
7489 \n\
7490 \n\
7491  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7492  levels.\n\
7493 \n\
7494  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7495 ";
7496 static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
7497 End plotting session for current stream\n\
7498 \n\
7499 DESCRIPTION:\n\
7500 \n\
7501  Ends a plotting session for the current output stream only. See\n\
7502  plsstrm for more info.\n\
7503 \n\
7504  Redacted form: plend1()\n\
7505 \n\
7506  This function is used in examples 1 and 20.\n\
7507 \n\
7508 \n\
7509 \n\
7510 SYNOPSIS:\n\
7511 \n\
7512 plend1()\n\
7513 ";
7514 static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
7515 Get y axis parameters\n\
7516 \n\
7517 DESCRIPTION:\n\
7518 \n\
7519  Identical to plgxax, except that arguments are flags for y axis. See\n\
7520  the description of plgxax for more detail.\n\
7521 \n\
7522  Redacted form: plgyax(p_digmax, p_digits)\n\
7523 \n\
7524  This function is used in example 31.\n\
7525 \n\
7526 \n\
7527 \n\
7528 SYNOPSIS:\n\
7529 \n\
7530 plgyax(p_digmax, p_digits)\n\
7531 \n\
7532 ARGUMENTS:\n\
7533 \n\
7534  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7535  number of digits for the y axis. If nonzero, the printed label\n\
7536  has been switched to a floating-point representation when the\n\
7537  number of digits exceeds this value.\n\
7538 \n\
7539  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7540  number of digits for the numeric labels (y axis) from the last\n\
7541  plot.\n\
7542 ";
7543 static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
7544 Set plot orientation\n\
7545 \n\
7546 DESCRIPTION:\n\
7547 \n\
7548  Set plot orientation parameter which is multiplied by 90 degrees to\n\
7549  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7550  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7551  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7552  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7553  (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7554  not called the default value of rot is 0.\n\
7555 \n\
7556  N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7557  probably want to change the aspect ratio to a value suitable for the\n\
7558  plot orientation using a call to plsdidev or the command-line options\n\
7559  -a or -freeaspect. For more documentation of those options see the\n\
7560  PLplot documentation. Such command-line options can be set internally\n\
7561  using plsetopt or set directly using the command line and parsed using\n\
7562  a call to plparseopts.\n\
7563 \n\
7564  Redacted form: plsdiori(rot)\n\
7565 \n\
7566  This function is not used in any examples.\n\
7567 \n\
7568 \n\
7569 \n\
7570 SYNOPSIS:\n\
7571 \n\
7572 plsdiori(rot)\n\
7573 \n\
7574 ARGUMENTS:\n\
7575 \n\
7576  rot (PLFLT, input) : Plot orientation parameter.\n\
7577 ";
7578 static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7579 Plot a histogram from unbinned data\n\
7580 \n\
7581 DESCRIPTION:\n\
7582 \n\
7583  Plots a histogram from n data points stored in the data vector. This\n\
7584  routine bins the data into nbin bins equally spaced between datmin and\n\
7585  datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7586  opt allows, among other things, the histogram either to be plotted in\n\
7587  an existing window or causes plhist to call plenv with suitable limits\n\
7588  before plotting the histogram.\n\
7589 \n\
7590  Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7591 \n\
7592  This function is used in example 5.\n\
7593 \n\
7594 \n\
7595 \n\
7596 SYNOPSIS:\n\
7597 \n\
7598 plhist(n, data, datmin, datmax, nbin, opt)\n\
7599 \n\
7600 ARGUMENTS:\n\
7601 \n\
7602  n (PLINT, input) : Number of data points.\n\
7603 \n\
7604  data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7605  n data points.\n\
7606 \n\
7607  datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7608 \n\
7609  datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7610 \n\
7611  nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7612  divide the interval xmin to xmax.\n\
7613 \n\
7614  opt (PLINT, input) : Is a combination of several flags:\n\
7615  opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7616  the histogram data, the outer bins are expanded to fill up the\n\
7617  entire x-axis, data outside the given extremes are assigned to the\n\
7618  outer bins and bins of zero height are simply drawn.\n\
7619  opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7620  to fit the histogram data, without this flag, plenv is called\n\
7621  to set the world coordinates.\n\
7622  opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7623  extremes are not taken into account. This option should\n\
7624  probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7625  properly present the data.\n\
7626  opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7627  size as the ones inside.\n\
7628  opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7629  (there is a gap for such bins).\n\
7630 ";
7631 static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
7632 End plotting session\n\
7633 \n\
7634 DESCRIPTION:\n\
7635 \n\
7636  Ends a plotting session, tidies up all the output files, switches\n\
7637  interactive devices back into text mode and frees up any memory that\n\
7638  was allocated. Must be called before end of program.\n\
7639 \n\
7640  By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7641  wait state after a call to plend or other functions which trigger the\n\
7642  end of a plot page. To avoid this, use the plspause function.\n\
7643 \n\
7644  Redacted form: plend()\n\
7645 \n\
7646  This function is used in all of the examples.\n\
7647 \n\
7648 \n\
7649 \n\
7650 SYNOPSIS:\n\
7651 \n\
7652 plend()\n\
7653 ";
7654 static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
7655 Plot shaded 3-d surface plot\n\
7656 \n\
7657 DESCRIPTION:\n\
7658 \n\
7659  Plots a three-dimensional shaded surface plot within the environment\n\
7660  set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7661  z[\n\
7662  nx][\n\
7663  ny], the point z[i][j] being the value of the function at (\n\
7664  x[i],\n\
7665  y[j]). Note that the points in vectors x and y do not need to be\n\
7666  equally spaced, but must be stored in ascending order. For further\n\
7667  details see the PLplot documentation.\n\
7668 \n\
7669  Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7670 \n\
7671  This function is not used in any examples.\n\
7672 \n\
7673 \n\
7674 \n\
7675 SYNOPSIS:\n\
7676 \n\
7677 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7678 \n\
7679 ARGUMENTS:\n\
7680 \n\
7681  x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7682  which the function is evaluated.\n\
7683 \n\
7684  y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7685  which the function is evaluated.\n\
7686 \n\
7687  z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7688  plot. Should have dimensions of\n\
7689  nx by\n\
7690  ny.\n\
7691 \n\
7692  nx (PLINT, input) : Number of x values at which function is\n\
7693  evaluated.\n\
7694 \n\
7695  ny (PLINT, input) : Number of y values at which function is\n\
7696  evaluated.\n\
7697 \n\
7698  opt (PLINT, input) : Determines the way in which the surface is\n\
7699  represented. To specify more than one option just add the options,\n\
7700  e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7701  connecting points at which function is defined.\n\
7702  opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7703  using parameters\n\
7704  nlevel and\n\
7705  clevel.\n\
7706  opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7707  using parameters\n\
7708  nlevel and\n\
7709  clevel.\n\
7710  opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7711  the borders of the plotted function.\n\
7712  opt=MAG_COLOR : the surface is colored according to the value\n\
7713  of Z; if MAG_COLOR is not used, then the surface is colored\n\
7714  according to the intensity of the reflected light in the\n\
7715  surface from a light source whose position is set using\n\
7716  pllightsource.\n\
7717 \n\
7718 \n\
7719  clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7720  levels.\n\
7721 \n\
7722  nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7723 ";
7724 static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
7725 Set device-compression level\n\
7726 \n\
7727 DESCRIPTION:\n\
7728 \n\
7729  Set device-compression level. Only used for drivers that provide\n\
7730  compression. This function, if used, should be invoked before a call\n\
7731  to plinit.\n\
7732 \n\
7733  Redacted form: plscompression(compression)\n\
7734 \n\
7735  This function is used in example 31.\n\
7736 \n\
7737 \n\
7738 \n\
7739 SYNOPSIS:\n\
7740 \n\
7741 plscompression(compression)\n\
7742 \n\
7743 ARGUMENTS:\n\
7744 \n\
7745  compression (PLINT, input) : The desired compression level. This is\n\
7746  a device-dependent value. Currently only the jpeg and png devices\n\
7747  use these values. For jpeg value is the jpeg quality which should\n\
7748  normally be in the range 0-95. Higher values denote higher quality\n\
7749  and hence larger image sizes. For png values are in the range -1\n\
7750  to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7751  A value of -1 denotes the default zlib compression level. Values\n\
7752  in the range 10-99 are divided by 10 and then used as the zlib\n\
7753  compression level. Higher compression levels correspond to greater\n\
7754  compression and small file sizes at the expense of more\n\
7755  computation.\n\
7756 ";
7757 static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
7758 Get the current device-compression setting\n\
7759 \n\
7760 DESCRIPTION:\n\
7761 \n\
7762  Get the current device-compression setting. This parameter is only\n\
7763  used for drivers that provide compression.\n\
7764 \n\
7765  Redacted form: plgcompression(compression)\n\
7766 \n\
7767  This function is used in example 31.\n\
7768 \n\
7769 \n\
7770 \n\
7771 SYNOPSIS:\n\
7772 \n\
7773 plgcompression(compression)\n\
7774 \n\
7775 ARGUMENTS:\n\
7776 \n\
7777  compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7778  compression setting for the current device.\n\
7779 ";
7780 static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
7781 Advance the (sub-)page\n\
7782 \n\
7783 DESCRIPTION:\n\
7784 \n\
7785  Advances to the next subpage if sub=0, performing a page advance if\n\
7786  there are no remaining subpages on the current page. If subpages\n\
7787  aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7788  PLplot switches to the specified subpage. Note that this allows you\n\
7789  to overwrite a plot on the specified subpage; if this is not what you\n\
7790  intended, use pleop followed by plbop to first advance the page. This\n\
7791  routine is called automatically (with page=0) by plenv, but if plenv\n\
7792  is not used, pladv must be called after initializing PLplot but before\n\
7793  defining the viewport.\n\
7794 \n\
7795  Redacted form: pladv(page)\n\
7796 \n\
7797  This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7798  29, and 31.\n\
7799 \n\
7800 \n\
7801 \n\
7802 SYNOPSIS:\n\
7803 \n\
7804 pladv(page)\n\
7805 \n\
7806 ARGUMENTS:\n\
7807 \n\
7808  page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7809  in the top left corner and increasing along the rows) to which to\n\
7810  advance. Set to zero to advance to the next subpage (or to the\n\
7811  next page if subpages are not being used).\n\
7812 ";
7813 static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7814 Set parameters of contour labelling other than format of numerical label\n\
7815 \n\
7816 DESCRIPTION:\n\
7817 \n\
7818  Set parameters of contour labelling other than those handled by\n\
7819  pl_setcontlabelformat.\n\
7820 \n\
7821  Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7822 \n\
7823  This function is used in example 9.\n\
7824 \n\
7825 \n\
7826 \n\
7827 SYNOPSIS:\n\
7828 \n\
7829 pl_setcontlabelparam(offset, size, spacing, active)\n\
7830 \n\
7831 ARGUMENTS:\n\
7832 \n\
7833  offset (PLFLT, input) : Offset of label from contour line (if set\n\
7834  to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7835 \n\
7836  size (PLFLT, input) : Font height for contour labels (normalized).\n\
7837  Default value is 0.3.\n\
7838 \n\
7839  spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7840  Default value is 0.1.\n\
7841 \n\
7842  active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7843  contour labels on. Default is off (0).\n\
7844 ";
7845 static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
7846 Set family, style and weight of the current font\n\
7847 \n\
7848 DESCRIPTION:\n\
7849 \n\
7850  Sets the current font. See the PLplot documentation for more\n\
7851  information on font selection.\n\
7852 \n\
7853  Redacted form: plsfont(family, style, weight)\n\
7854 \n\
7855  This function is used in example 23.\n\
7856 \n\
7857 \n\
7858 \n\
7859 SYNOPSIS:\n\
7860 \n\
7861 plsfont(family, style, weight)\n\
7862 \n\
7863 ARGUMENTS:\n\
7864 \n\
7865  family (PLINT, input) : Font family to select for the current font.\n\
7866  The available values are given by the PL_FCI_* constants in\n\
7867  plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7868  PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7869  signifies that the font family should not be altered.\n\
7870 \n\
7871  style (PLINT, input) : Font style to select for the current font.\n\
7872  The available values are given by the PL_FCI_* constants in\n\
7873  plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7874  PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7875  should not be altered.\n\
7876 \n\
7877  weight (PLINT, input) : Font weight to select for the current font.\n\
7878  The available values are given by the PL_FCI_* constants in\n\
7879  plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7880  negative value signifies that the font weight should not be\n\
7881  altered.\n\
7882 ";
7883 static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
7884 Sets the 3D position of the light source\n\
7885 \n\
7886 DESCRIPTION:\n\
7887 \n\
7888  Sets the 3D position of the light source for use with plsurf3d and\n\
7889  plsurf3dl\n\
7890 \n\
7891  Redacted form: pllightsource(x, y, z)\n\
7892 \n\
7893  This function is used in example 8.\n\
7894 \n\
7895 \n\
7896 \n\
7897 SYNOPSIS:\n\
7898 \n\
7899 pllightsource(x, y, z)\n\
7900 \n\
7901 ARGUMENTS:\n\
7902 \n\
7903  x (PLFLT, input) : X-coordinate of the light source.\n\
7904 \n\
7905  y (PLFLT, input) : Y-coordinate of the light source.\n\
7906 \n\
7907  z (PLFLT, input) : Z-coordinate of the light source.\n\
7908 ";
7909 static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
7910 Draw a line\n\
7911 \n\
7912 DESCRIPTION:\n\
7913 \n\
7914  Draws line defined by n points in x and y.\n\
7915 \n\
7916  Redacted form: plline(x, y)\n\
7917 \n\
7918  This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
7919  25-27, and 29.\n\
7920 \n\
7921 \n\
7922 \n\
7923 SYNOPSIS:\n\
7924 \n\
7925 plline(n, x, y)\n\
7926 \n\
7927 ARGUMENTS:\n\
7928 \n\
7929  n (PLINT, input) : Number of points defining line.\n\
7930 \n\
7931  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7932  points.\n\
7933 \n\
7934  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7935  points.\n\
7936 ";
7937 static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
7938 Set pen width\n\
7939 \n\
7940 DESCRIPTION:\n\
7941 \n\
7942  Sets the pen width.\n\
7943 \n\
7944  Redacted form: plwidth(width)\n\
7945 \n\
7946  This function is used in examples 1 and 2.\n\
7947 \n\
7948 \n\
7949 \n\
7950 SYNOPSIS:\n\
7951 \n\
7952 plwidth(width)\n\
7953 \n\
7954 ARGUMENTS:\n\
7955 \n\
7956  width (PLFLT, input) : The desired pen width. If width is negative\n\
7957  or the same as the previous value no action is taken. width = 0.\n\
7958  should be interpreted as as the minimum valid pen width for the\n\
7959  device. The interpretation of positive width values is also\n\
7960  device dependent.\n\
7961 ";
7962 static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
7963 Draw linear gradient inside polygon\n\
7964 \n\
7965 DESCRIPTION:\n\
7966 \n\
7967  Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
7968  points (\n\
7969  x[i],\n\
7970  y[i]). Interpretation of the polygon is the same as for plfill. The\n\
7971  polygon coordinates and the gradient angle are all expressed in world\n\
7972  coordinates. The angle from the x axis for both the rotated\n\
7973  coordinate system and the gradient vector is specified by angle. The\n\
7974  magnitude of the gradient vector is the difference between the maximum\n\
7975  and minimum values of x for the vertices in the rotated coordinate\n\
7976  system. The origin of the gradient vector can be interpreted as being\n\
7977  anywhere on the line corresponding to the minimum x value for the\n\
7978  vertices in the rotated coordinate system. The distance along the\n\
7979  gradient vector is linearly transformed to the independent variable of\n\
7980  color map 1 which ranges from 0. at the tail of the gradient vector to\n\
7981  1. at the head of the gradient vector. What is drawn is the RGBA\n\
7982  color corresponding to the independent variable of cmap1. For more\n\
7983  information about cmap1 (see the PLplot documentation).\n\
7984 \n\
7985  Redacted form: plgradient(x,y,angle)\n\
7986 \n\
7987  This function is used in examples 25 and 30.\n\
7988 \n\
7989 \n\
7990 \n\
7991 SYNOPSIS:\n\
7992 \n\
7993 plgradient(n, x, y, angle)\n\
7994 \n\
7995 ARGUMENTS:\n\
7996 \n\
7997  n (PLINT, input) : Number of vertices in polygon.\n\
7998 \n\
7999  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
8000  vertices.\n\
8001 \n\
8002  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8003  vertices.\n\
8004 \n\
8005  angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
8006  axis.\n\
8007 ";
8008 static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
8009 Flushes the output stream\n\
8010 \n\
8011 DESCRIPTION:\n\
8012 \n\
8013  Flushes the output stream. Use sparingly, if at all.\n\
8014 \n\
8015  Redacted form: plflush()\n\
8016 \n\
8017  This function is used in examples 1 and 14.\n\
8018 \n\
8019 \n\
8020 \n\
8021 SYNOPSIS:\n\
8022 \n\
8023 plflush()\n\
8024 ";
8025 static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
8026 Get plot orientation\n\
8027 \n\
8028 DESCRIPTION:\n\
8029 \n\
8030  Get plot orientation parameter which is multiplied by 90 degrees to\n\
8031  obtain the angle of rotation. Note, arbitrary rotation parameters\n\
8032  such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
8033  values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
8034  to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
8035  (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
8036  not been called the default value pointed to by p_rot will be 0.\n\
8037 \n\
8038  Redacted form: plgdiori(p_rot)\n\
8039 \n\
8040  This function is not used in any examples.\n\
8041 \n\
8042 \n\
8043 \n\
8044 SYNOPSIS:\n\
8045 \n\
8046 plgdiori(p_rot)\n\
8047 \n\
8048 ARGUMENTS:\n\
8049 \n\
8050  p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
8051  parameter.\n\
8052 ";
8053 static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
8054 Set x axis parameters\n\
8055 \n\
8056 DESCRIPTION:\n\
8057 \n\
8058  Sets values of the digmax and digits flags for the x axis. See the\n\
8059  PLplot documentation for more information.\n\
8060 \n\
8061  Redacted form: plsxax(digmax, digits)\n\
8062 \n\
8063  This function is used in example 31.\n\
8064 \n\
8065 \n\
8066 \n\
8067 SYNOPSIS:\n\
8068 \n\
8069 plsxax(digmax, digits)\n\
8070 \n\
8071 ARGUMENTS:\n\
8072 \n\
8073  digmax (PLINT, input) : Variable to set the maximum number of\n\
8074  digits for the x axis. If nonzero, the printed label will be\n\
8075  switched to a floating-point representation when the number of\n\
8076  digits exceeds digmax.\n\
8077 \n\
8078  digits (PLINT, input) : Field digits value. Currently, changing\n\
8079  its value here has no effect since it is set only by plbox or\n\
8080  plbox3. However, the user may obtain its value after a call to\n\
8081  either of these functions by calling plgxax.\n\
8082 ";
8083 static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
8084 Get viewport limits in world coordinates\n\
8085 \n\
8086 DESCRIPTION:\n\
8087 \n\
8088  Get viewport limits in world coordinates.\n\
8089 \n\
8090  Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8091 \n\
8092 \n\
8093  This function is used in example 31.\n\
8094 \n\
8095 \n\
8096 \n\
8097 SYNOPSIS:\n\
8098 \n\
8099 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8100 \n\
8101 ARGUMENTS:\n\
8102 \n\
8103  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8104  viewport limit of the world coordinate in x.\n\
8105 \n\
8106  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8107  viewport limit of the world coordinate in x.\n\
8108 \n\
8109  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8110  viewport limit of the world coordinate in y.\n\
8111 \n\
8112  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8113  viewport limit of the world coordinate in y.\n\
8114 ";
8115 static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
8116 Shade regions on the basis of value\n\
8117 \n\
8118 DESCRIPTION:\n\
8119 \n\
8120  Shade regions on the basis of value. This is the high-level routine\n\
8121  for making continuous color shaded plots with cmap1 while plshade\n\
8122  should be used to plot individual shaded regions using either cmap0 or\n\
8123  cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
8124  our supported languages.\n\
8125 \n\
8126  Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
8127  clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
8128  pltr_data)\n\
8129 \n\
8130 \n\
8131  This function is used in examples 16, 21, and 22.\n\
8132 \n\
8133 \n\
8134 \n\
8135 SYNOPSIS:\n\
8136 \n\
8137 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
8138 \n\
8139 ARGUMENTS:\n\
8140 \n\
8141  a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8142  plot. Should have dimensions of\n\
8143  nx by\n\
8144  ny.\n\
8145 \n\
8146  nx (PLINT, input) : First dimension of matrix \"a\".\n\
8147 \n\
8148  ny (PLINT, input) : Second dimension of matrix \"a\".\n\
8149 \n\
8150  defined (PLDEFINED_callback, input) : Callback function specifying\n\
8151  the region that should be plotted in the shade plot. This\n\
8152  function accepts x and y coordinates as input arguments and must\n\
8153  return 1 if the point is to be included in the shade plot and 0\n\
8154  otherwise. If you want to plot the entire shade plot (the usual\n\
8155  case), this argument should be set to NULL.\n\
8156 \n\
8157  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8158  pltr below for how these arguments are used (only for the special case\n\
8159  when the callback function\n\
8160  pltr is not supplied).\n\
8161 \n\
8162  clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
8163  corresponding to the edges of each shaded region that will be\n\
8164  plotted by this function. To work properly the levels should be\n\
8165  monotonic.\n\
8166 \n\
8167  nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
8168  of shade edge values in clevel).\n\
8169 \n\
8170  fill_width (PLFLT, input) : Defines the line width used by the fill\n\
8171  pattern.\n\
8172 \n\
8173  cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
8174  contours defining edges of shaded regions. The pen color is only\n\
8175  temporary set for the contour drawing. Set this value to zero or\n\
8176  less if no shade edge contours are wanted.\n\
8177 \n\
8178  cont_width (PLFLT, input) : Defines line width used for contours\n\
8179  defining edges of shaded regions. This value may not be honored\n\
8180  by all drivers. The pen width is only temporary set for the\n\
8181  contour drawing. Set this value to zero or less if no shade edge\n\
8182  contours are wanted.\n\
8183 \n\
8184  fill (PLFILL_callback, input) : Callback routine used to fill the\n\
8185  region. Use plfill for this purpose.\n\
8186 \n\
8187  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8188  map to rectangles after coordinate transformation with pltrl.\n\
8189  Otherwise, set rectangular to false. If rectangular is set to\n\
8190  true, plshade tries to save time by filling large rectangles.\n\
8191  This optimization fails if the coordinate transformation distorts\n\
8192  the shape of rectangles. For example a plot in polar coordinates\n\
8193  has to have rectangular set to false.\n\
8194 \n\
8195  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8196  defines the transformation between the zero-based indices of the\n\
8197  matrix a and world coordinates. If\n\
8198  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8199  indices of a are mapped to the range\n\
8200  xmin through\n\
8201  xmax and the y indices of a are mapped to the range\n\
8202  ymin through\n\
8203  ymax.For the C case, transformation functions are provided in the\n\
8204  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8205  pltr2 for arbitrary mappings respectively defined by vectors and\n\
8206  matrices. In addition, C callback routines for the transformation\n\
8207  can be supplied by the user such as the mypltr function in\n\
8208  examples/c/x09c.c which provides a general linear transformation\n\
8209  between index coordinates and world coordinates.For languages\n\
8210  other than C you should consult the PLplot documentation for the\n\
8211  details concerning how PLTRANSFORM_callback arguments are\n\
8212  interfaced. However, in general, a particular pattern of\n\
8213  callback-associated arguments such as a tr vector with 6 elements;\n\
8214  xg and yg vectors; or xg and yg matrices are respectively\n\
8215  interfaced to a linear-transformation routine similar to the above\n\
8216  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8217  sophisticated bindings (see, e.g., the PLplot documentation)\n\
8218  support native language callbacks for handling index to\n\
8219  world-coordinate transformations. Examples of these various\n\
8220  approaches are given in examples/<language>x09*,\n\
8221  examples/<language>x16*, examples/<language>x20*,\n\
8222  examples/<language>x21*, and examples/<language>x22*, for all our\n\
8223  supported languages.\n\
8224 \n\
8225  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8226  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8227  externally supplied.\n\
8228 ";
8229 static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
8230 Plot color bar for image, shade or gradient plots\n\
8231 \n\
8232 DESCRIPTION:\n\
8233 \n\
8234  Routine for creating a continuous color bar for image, shade, or\n\
8235  gradient plots. (See pllegend for similar functionality for creating\n\
8236  legends with discrete elements). The arguments of plcolorbar provide\n\
8237  control over the location and size of the color bar as well as the\n\
8238  location and characteristics of the elements (most of which are\n\
8239  optional) within that color bar. The resulting color bar is clipped\n\
8240  at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
8241  system used for some of the parameters is defined in the documentation\n\
8242  of the position parameter.)\n\
8243 \n\
8244  Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
8245  position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
8246  low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
8247  labels, axis_opts, ticks, sub_ticks, values)\n\
8248 \n\
8249  This function is used in examples 16 and 33.\n\
8250 \n\
8251 \n\
8252 \n\
8253 SYNOPSIS:\n\
8254 \n\
8255 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\
8256 \n\
8257 ARGUMENTS:\n\
8258 \n\
8259  p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8260  labelled and decorated color bar width in adopted coordinates.\n\
8261 \n\
8262  p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8263  labelled and decorated color bar height in adopted coordinates.\n\
8264 \n\
8265  opt (PLINT, input) : opt contains bits controlling the overall\n\
8266  color bar. The orientation (direction of the maximum value) of\n\
8267  the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
8268  PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
8269  specified, the default orientation is toward the top if the\n\
8270  colorbar is placed on the left or right of the viewport or toward\n\
8271  the right if the colorbar is placed on the top or bottom of the\n\
8272  viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
8273  (semitransparent) background for the color bar. If the\n\
8274  PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8275  color bar. The type of color bar must be specified with one of\n\
8276  PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
8277  more than one of those bits is set only the first one in the above\n\
8278  list is honored. The position of the (optional) label/title can be\n\
8279  specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
8280  PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
8281  will be drawn. If more than one of this list of bits is specified,\n\
8282  only the first one on the list is honored. End-caps for the color\n\
8283  bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
8284  If a particular color bar cap option is not specified then no cap\n\
8285  will be drawn for that end. As a special case for\n\
8286  PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
8287  specified. If this option is provided then any tick marks and tick\n\
8288  labels will be placed at the breaks between shaded segments. TODO:\n\
8289  This should be expanded to support custom placement of tick marks\n\
8290  and tick labels at custom value locations for any color bar type.\n\
8291 \n\
8292  position (PLINT, input) : position contains bits which control the\n\
8293  overall position of the color bar and the definition of the\n\
8294  adopted coordinates used for positions just like what is done for\n\
8295  the position argument for pllegend. However, note that the\n\
8296  defaults for the position bits (see below) are different than the\n\
8297  pllegend case. The combination of the PL_POSITION_LEFT,\n\
8298  PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8299  PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8300  the 16 possible standard positions (the 4 corners and centers of\n\
8301  the 4 sides for both the inside and outside cases) of the color\n\
8302  bar relative to the adopted coordinate system. The corner\n\
8303  positions are specified by the appropriate combination of two of\n\
8304  the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8305  PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8306  value of one of those bits. The adopted coordinates are\n\
8307  normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8308  set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8309  bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8310  PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8311  then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
8312  PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
8313  PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
8314  PL_POSITION_VIEWPORT.\n\
8315 \n\
8316  x (PLFLT, input) : X offset of the color bar position in adopted\n\
8317  coordinates from the specified standard position of the color bar.\n\
8318  For positive x, the direction of motion away from the standard\n\
8319  position is inward/outward from the standard corner positions or\n\
8320  standard left or right positions if the\n\
8321  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8322  For the standard top or bottom positions, the direction of motion\n\
8323  is toward positive X.\n\
8324 \n\
8325  y (PLFLT, input) : Y offset of the color bar position in adopted\n\
8326  coordinates from the specified standard position of the color bar.\n\
8327  For positive y, the direction of motion away from the standard\n\
8328  position is inward/outward from the standard corner positions or\n\
8329  standard top or bottom positions if the\n\
8330  PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8331  For the standard left or right positions, the direction of motion\n\
8332  is toward positive Y.\n\
8333 \n\
8334  x_length (PLFLT, input) : Length of the body of the color bar in\n\
8335  the X direction in adopted coordinates.\n\
8336 \n\
8337  y_length (PLFLT, input) : Length of the body of the color bar in\n\
8338  the Y direction in adopted coordinates.\n\
8339 \n\
8340  bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8341  color bar (PL_COLORBAR_BACKGROUND).\n\
8342 \n\
8343  bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8344  for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8345 \n\
8346  bb_style (PLINT, input) : The pllsty style number for the\n\
8347  bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8348 \n\
8349  low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8350  bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8351 \n\
8352  high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8353  color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8354 \n\
8355  cont_color (PLINT, input) : The cmap0 contour color for\n\
8356  PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8357  it will be interpreted according to the design of plshades.\n\
8358 \n\
8359  cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8360  plots. This is passed directly to plshades, so it will be\n\
8361  interpreted according to the design of plshades.\n\
8362 \n\
8363  n_labels (PLINT, input) : Number of labels to place around the\n\
8364  color bar.\n\
8365 \n\
8366  label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8367  n_labels labels.\n\
8368 \n\
8369  labels (PLCHAR_MATRIX, input) : A vector of\n\
8370  n_labels UTF-8 character strings containing the labels for the color\n\
8371  bar. Ignored if no label position is specified with one of the\n\
8372  PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8373  PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8374  corresponding label_opts field.\n\
8375 \n\
8376  n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8377  value must be greater than 0. It is typically 1 (numerical axis\n\
8378  labels are provided for one of the long edges of the color bar),\n\
8379  but it can be larger if multiple numerical axis labels for the\n\
8380  long edges of the color bar are desired.\n\
8381 \n\
8382  axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8383  n_axes ascii character strings containing options (interpreted as for\n\
8384  plbox) for the color bar\'s axis definitions.\n\
8385 \n\
8386  ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8387  spacing of the major tick marks (interpreted as for plbox) for the\n\
8388  color bar\'s axis definitions.\n\
8389 \n\
8390  sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8391  number of subticks (interpreted as for plbox) for the color bar\'s\n\
8392  axis definitions.\n\
8393 \n\
8394  n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8395  elements in each of the n_axes rows of the values matrix.\n\
8396 \n\
8397  values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8398  values for the data range represented by the color bar. For a row\n\
8399  index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8400  elements in the row is specified by n_values[i_axis]. For\n\
8401  PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8402  is 2, and the corresponding row elements of the values matrix are\n\
8403  the minimum and maximum value represented by the colorbar. For\n\
8404  PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8405  of the values matrix is interpreted the same as the nlevel and\n\
8406  clevel arguments of plshades.\n\
8407 ";
8408 static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
8409 Get current subpage parameters\n\
8410 \n\
8411 DESCRIPTION:\n\
8412 \n\
8413  Gets the size of the current subpage in millimeters measured from the\n\
8414  bottom left hand corner of the output device page or screen. Can be\n\
8415  used in conjunction with plsvpa for setting the size of a viewport in\n\
8416  absolute coordinates (millimeters).\n\
8417 \n\
8418  Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8419 \n\
8420  This function is used in example 23.\n\
8421 \n\
8422 \n\
8423 \n\
8424 SYNOPSIS:\n\
8425 \n\
8426 plgspa(xmin, xmax, ymin, ymax)\n\
8427 \n\
8428 ARGUMENTS:\n\
8429 \n\
8430  xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8431  the left hand edge of the subpage in millimeters.\n\
8432 \n\
8433  xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8434  the right hand edge of the subpage in millimeters.\n\
8435 \n\
8436  ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8437  the bottom edge of the subpage in millimeters.\n\
8438 \n\
8439  ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8440  the top edge of the subpage in millimeters.\n\
8441 ";
8442 static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
8443 Shade individual region on the basis of value\n\
8444 \n\
8445 DESCRIPTION:\n\
8446 \n\
8447  Shade individual region on the basis of value. Use plshades if you\n\
8448  want to shade a number of contiguous regions using continuous colors.\n\
8449  In particular the edge contours are treated properly in plshades. If\n\
8450  you attempt to do contiguous regions with plshade the contours at the\n\
8451  edge of the shade are partially obliterated by subsequent plots of\n\
8452  contiguous shaded regions.\n\
8453 \n\
8454  Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8455  shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8456  min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8457 \n\
8458 \n\
8459  This function is used in example 15.\n\
8460 \n\
8461 \n\
8462 \n\
8463 SYNOPSIS:\n\
8464 \n\
8465 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\
8466 \n\
8467 ARGUMENTS:\n\
8468 \n\
8469  a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8470  plot. Should have dimensions of\n\
8471  nx by\n\
8472  ny.\n\
8473 \n\
8474  nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8475 \n\
8476  ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8477 \n\
8478  defined (PLDEFINED_callback, input) : Callback function specifying\n\
8479  the region that should be plotted in the shade plot. This\n\
8480  function accepts x and y coordinates as input arguments and must\n\
8481  return 1 if the point is to be included in the shade plot and 0\n\
8482  otherwise. If you want to plot the entire shade plot (the usual\n\
8483  case), this argument should be set to NULL.\n\
8484 \n\
8485  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8486  pltr below for how these arguments are used (only for the special case\n\
8487  when the callback function\n\
8488  pltr is not supplied).\n\
8489 \n\
8490  shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8491  be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8492 \n\
8493  shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8494  be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8495 \n\
8496  sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8497  sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8498  then sh_color is interpreted as a cmap1 argument in the range\n\
8499  (0.0-1.0).\n\
8500 \n\
8501  sh_color (PLFLT, input) : Defines color map index with integer\n\
8502  value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8503 \n\
8504  sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8505 \n\
8506  min_color (PLINT, input) : Defines pen color, width used by the\n\
8507  boundary of shaded region. The min values are used for the\n\
8508  shade_min boundary, and the max values are used on the shade_max\n\
8509  boundary. Set color and width to zero for no plotted boundaries.\n\
8510 \n\
8511  min_width (PLFLT, input) : Defines pen color, width used by the\n\
8512  boundary of shaded region. The min values are used for the\n\
8513  shade_min boundary, and the max values are used on the shade_max\n\
8514  boundary. Set color and width to zero for no plotted boundaries.\n\
8515 \n\
8516  max_color (PLINT, input) : Defines pen color, width used by the\n\
8517  boundary of shaded region. The min values are used for the\n\
8518  shade_min boundary, and the max values are used on the shade_max\n\
8519  boundary. Set color and width to zero for no plotted boundaries.\n\
8520 \n\
8521  max_width (PLFLT, input) : Defines pen color, width used by the\n\
8522  boundary of shaded region. The min values are used for the\n\
8523  shade_min boundary, and the max values are used on the shade_max\n\
8524  boundary. Set color and width to zero for no plotted boundaries.\n\
8525 \n\
8526  fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8527  Use plfill. Future version of PLplot may have other fill\n\
8528  routines.\n\
8529 \n\
8530  rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8531  map to rectangles after coordinate transformation with pltrl.\n\
8532  Otherwise, set rectangular to false. If rectangular is set to\n\
8533  true, plshade tries to save time by filling large rectangles.\n\
8534  This optimization fails if the coordinate transformation distorts\n\
8535  the shape of rectangles. For example a plot in polar coordinates\n\
8536  has to have rectangular set to false.\n\
8537 \n\
8538  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8539  defines the transformation between the zero-based indices of the\n\
8540  matrix a and world coordinates. If\n\
8541  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8542  indices of a are mapped to the range\n\
8543  xmin through\n\
8544  xmax and the y indices of a are mapped to the range\n\
8545  ymin through\n\
8546  ymax.For the C case, transformation functions are provided in the\n\
8547  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8548  pltr2 for arbitrary mappings respectively defined by vectors and\n\
8549  matrices. In addition, C callback routines for the transformation\n\
8550  can be supplied by the user such as the mypltr function in\n\
8551  examples/c/x09c.c which provides a general linear transformation\n\
8552  between index coordinates and world coordinates.For languages\n\
8553  other than C you should consult the PLplot documentation for the\n\
8554  details concerning how PLTRANSFORM_callback arguments are\n\
8555  interfaced. However, in general, a particular pattern of\n\
8556  callback-associated arguments such as a tr vector with 6 elements;\n\
8557  xg and yg vectors; or xg and yg matrices are respectively\n\
8558  interfaced to a linear-transformation routine similar to the above\n\
8559  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8560  sophisticated bindings (see, e.g., the PLplot documentation)\n\
8561  support native language callbacks for handling index to\n\
8562  world-coordinate transformations. Examples of these various\n\
8563  approaches are given in examples/<language>x09*,\n\
8564  examples/<language>x16*, examples/<language>x20*,\n\
8565  examples/<language>x21*, and examples/<language>x22*, for all our\n\
8566  supported languages.\n\
8567 \n\
8568  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8569  information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8570  externally supplied.\n\
8571 ";
8572 static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
8573 Calculate world coordinates and corresponding window index from relative device coordinates\n\
8574 \n\
8575 DESCRIPTION:\n\
8576 \n\
8577  Calculate world coordinates, wx and wy, and corresponding window index\n\
8578  from relative device coordinates, rx and ry.\n\
8579 \n\
8580  Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8581 \n\
8582 \n\
8583  This function is used in example 31.\n\
8584 \n\
8585 \n\
8586 \n\
8587 SYNOPSIS:\n\
8588 \n\
8589 plcalc_world(rx, ry, wx, wy, window)\n\
8590 \n\
8591 ARGUMENTS:\n\
8592 \n\
8593  rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8594  the x coordinate.\n\
8595 \n\
8596  ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8597  the y coordinate.\n\
8598 \n\
8599  wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8600  coordinate corresponding to the relative device coordinates rx and\n\
8601  ry.\n\
8602 \n\
8603  wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8604  coordinate corresponding to the relative device coordinates rx and\n\
8605  ry.\n\
8606 \n\
8607  window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8608  defined window index that corresponds to the input relative device\n\
8609  coordinates (and the returned world coordinates). To give some\n\
8610  background on the window index, for each page the initial window\n\
8611  index is set to zero, and each time plwind is called within the\n\
8612  page, world and device coordinates are stored for the window and\n\
8613  the window index is incremented. Thus, for a simple page layout\n\
8614  with non-overlapping viewports and one window per viewport, window\n\
8615  corresponds to the viewport index (in the order which the\n\
8616  viewport/windows were created) of the only viewport/window\n\
8617  corresponding to rx and ry. However, for more complicated layouts\n\
8618  with potentially overlapping viewports and possibly more than one\n\
8619  window (set of world coordinates) per viewport, window and the\n\
8620  corresponding output world coordinates corresponds to the last\n\
8621  window created that fulfills the criterion that the relative\n\
8622  device coordinates are inside it. Finally, in all cases where the\n\
8623  input relative device coordinates are not inside any\n\
8624  viewport/window, then the returned value of the last defined\n\
8625  window index is set to -1.\n\
8626 ";
8627 static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
8628 Draw a box with axes, etc, in 3-d\n\
8629 \n\
8630 DESCRIPTION:\n\
8631 \n\
8632  Draws axes, numeric and text labels for a three-dimensional surface\n\
8633  plot. For a more complete description of three-dimensional plotting\n\
8634  see the PLplot documentation.\n\
8635 \n\
8636  Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8637  ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8638 \n\
8639 \n\
8640  This function is used in examples 8, 11, 18, and 21.\n\
8641 \n\
8642 \n\
8643 \n\
8644 SYNOPSIS:\n\
8645 \n\
8646 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8647 \n\
8648 ARGUMENTS:\n\
8649 \n\
8650  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8651  options for the x axis. The string can include any combination of\n\
8652  the following letters (upper or lower case) in any order: b: Draws\n\
8653  axis at base, at height z=\n\
8654  zmin where zmin is defined by call to plw3d. This character must be\n\
8655  specified in order to use any of the other options.\n\
8656  d: Plot labels as date / time. Values are assumed to be\n\
8657  seconds since the epoch (as used by gmtime).\n\
8658  f: Always use fixed point numeric labels.\n\
8659  i: Inverts tick marks, so they are drawn downwards, rather\n\
8660  than upwards.\n\
8661  l: Labels axis logarithmically. This only affects the labels,\n\
8662  not the data, and so it is necessary to compute the logarithms\n\
8663  of data points before passing them to any of the drawing\n\
8664  routines.\n\
8665  n: Writes numeric labels at major tick intervals.\n\
8666  o: Use custom labelling function to generate axis label text.\n\
8667  The custom labelling function can be defined with the\n\
8668  plslabelfunc command.\n\
8669  s: Enables subticks between major ticks, only valid if t is\n\
8670  also specified.\n\
8671  t: Draws major ticks.\n\
8672  u: If this is specified, the text label for the axis is\n\
8673  written under the axis.\n\
8674 \n\
8675 \n\
8676  xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8677  the text label for the x axis. It is only drawn if u is in the\n\
8678  xopt string.\n\
8679 \n\
8680  xtick (PLFLT, input) : World coordinate interval between major\n\
8681  ticks on the x axis. If it is set to zero, PLplot automatically\n\
8682  generates a suitable tick interval.\n\
8683 \n\
8684  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8685  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8686  generates a suitable minor tick interval.\n\
8687 \n\
8688  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8689  options for the y axis. The string is interpreted in the same way\n\
8690  as xopt.\n\
8691 \n\
8692  ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8693  the text label for the y axis. It is only drawn if u is in the\n\
8694  yopt string.\n\
8695 \n\
8696  ytick (PLFLT, input) : World coordinate interval between major\n\
8697  ticks on the y axis. If it is set to zero, PLplot automatically\n\
8698  generates a suitable tick interval.\n\
8699 \n\
8700  nysub (PLINT, input) : Number of subintervals between major y axis\n\
8701  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8702  generates a suitable minor tick interval.\n\
8703 \n\
8704  zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8705  options for the z axis. The string can include any combination of\n\
8706  the following letters (upper or lower case) in any order: b: Draws\n\
8707  z axis to the left of the surface plot.\n\
8708  c: Draws z axis to the right of the surface plot.\n\
8709  d: Draws grid lines parallel to the x-y plane behind the\n\
8710  figure. These lines are not drawn until after plot3d or\n\
8711  plmesh are called because of the need for hidden line removal.\n\
8712  e: Plot labels as date / time. Values are assumed to be\n\
8713  seconds since the epoch (as used by gmtime). Note this\n\
8714  suboption is interpreted the same as the d suboption for xopt\n\
8715  and yopt, but it has to be identified as e for zopt since d\n\
8716  has already been used for the different purpose above.\n\
8717  f: Always use fixed point numeric labels.\n\
8718  i: Inverts tick marks, so they are drawn away from the center.\n\
8719  l: Labels axis logarithmically. This only affects the labels,\n\
8720  not the data, and so it is necessary to compute the logarithms\n\
8721  of data points before passing them to any of the drawing\n\
8722  routines.\n\
8723  m: Writes numeric labels at major tick intervals on the\n\
8724  right-hand z axis.\n\
8725  n: Writes numeric labels at major tick intervals on the\n\
8726  left-hand z axis.\n\
8727  o: Use custom labelling function to generate axis label text.\n\
8728  The custom labelling function can be defined with the\n\
8729  plslabelfunc command.\n\
8730  s: Enables subticks between major ticks, only valid if t is\n\
8731  also specified.\n\
8732  t: Draws major ticks.\n\
8733  u: If this is specified, the text label is written beside the\n\
8734  left-hand axis.\n\
8735  v: If this is specified, the text label is written beside the\n\
8736  right-hand axis.\n\
8737 \n\
8738 \n\
8739  zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8740  the text label for the z axis. It is only drawn if u or v are in\n\
8741  the zopt string.\n\
8742 \n\
8743  ztick (PLFLT, input) : World coordinate interval between major\n\
8744  ticks on the z axis. If it is set to zero, PLplot automatically\n\
8745  generates a suitable tick interval.\n\
8746 \n\
8747  nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8748  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8749  generates a suitable minor tick interval.\n\
8750 ";
8751 static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
8752 Get character default height and current (scaled) height\n\
8753 \n\
8754 DESCRIPTION:\n\
8755 \n\
8756  Get character default height and current (scaled) height.\n\
8757 \n\
8758  Redacted form: plgchr(p_def, p_ht)\n\
8759 \n\
8760  This function is used in example 23.\n\
8761 \n\
8762 \n\
8763 \n\
8764 SYNOPSIS:\n\
8765 \n\
8766 plgchr(p_def, p_ht)\n\
8767 \n\
8768 ARGUMENTS:\n\
8769 \n\
8770  p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8771  character height (mm).\n\
8772 \n\
8773  p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8774  character height (mm).\n\
8775 ";
8776 static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
8777 Set the escape character for text strings\n\
8778 \n\
8779 DESCRIPTION:\n\
8780 \n\
8781  Set the escape character for text strings. From C (in contrast to\n\
8782  Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
8783  characters are allowed to prevent the user from shooting himself in\n\
8784  the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
8785  use of backslash as a character escape). Here are the allowed escape\n\
8786  characters and their corresponding decimal ASCII values: !, ASCII 33\n\
8787  #, ASCII 35\n\
8788  $, ASCII 36\n\
8789  %, ASCII 37\n\
8790  &, ASCII 38\n\
8791  *, ASCII 42\n\
8792  @, ASCII 64\n\
8793  ^, ASCII 94\n\
8794  ~, ASCII 126\n\
8795 \n\
8796 \n\
8797  Redacted form: General: plsesc(esc)\n\
8798 \n\
8799 \n\
8800  This function is used in example 29.\n\
8801 \n\
8802 \n\
8803 \n\
8804 SYNOPSIS:\n\
8805 \n\
8806 plsesc(esc)\n\
8807 \n\
8808 ARGUMENTS:\n\
8809 \n\
8810  esc (char, input) : Escape character.\n\
8811 ";
8812 static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
8813 Draw a line between two points, accounting for coordinate transforms\n\
8814 \n\
8815 DESCRIPTION:\n\
8816 \n\
8817  Joins the point (\n\
8818  x1,\n\
8819  y1) to (\n\
8820  x2,\n\
8821  y2) . If a global coordinate transform is defined then the line is\n\
8822  broken in to n segments to approximate the path. If no transform is\n\
8823  defined then this simply acts like a call to pljoin.\n\
8824 \n\
8825  Redacted form: plpath(n,x1,y1,x2,y2)\n\
8826 \n\
8827  This function is used in example 22.\n\
8828 \n\
8829 \n\
8830 \n\
8831 SYNOPSIS:\n\
8832 \n\
8833 plpath(n, x1, y1, x2, y2)\n\
8834 \n\
8835 ARGUMENTS:\n\
8836 \n\
8837  n (PLINT, input) : number of points to use to approximate the path.\n\
8838 \n\
8839  x1 (PLFLT, input) : x coordinate of first point.\n\
8840 \n\
8841  y1 (PLFLT, input) : y coordinate of first point.\n\
8842 \n\
8843  x2 (PLFLT, input) : x coordinate of second point.\n\
8844 \n\
8845  y2 (PLFLT, input) : y coordinate of second point.\n\
8846 ";
8847 static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
8848 Set up standard window and draw box\n\
8849 \n\
8850 DESCRIPTION:\n\
8851 \n\
8852  Sets up plotter environment for simple graphs by calling pladv and\n\
8853  setting up viewport and window to sensible default values. plenv\n\
8854  leaves a standard margin (left-hand margin of eight character heights,\n\
8855  and a margin around the other three sides of five character heights)\n\
8856  around most graphs for axis labels and a title. When these defaults\n\
8857  are not suitable, use the individual routines plvpas, plvpor, or\n\
8858  plvasp for setting up the viewport, plwind for defining the window,\n\
8859  and plbox for drawing the box.\n\
8860 \n\
8861  Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8862 \n\
8863  This function is used in example 1,3,9,13,14,19-22,29.\n\
8864 \n\
8865 \n\
8866 \n\
8867 SYNOPSIS:\n\
8868 \n\
8869 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8870 \n\
8871 ARGUMENTS:\n\
8872 \n\
8873  xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8874  world coordinates).\n\
8875 \n\
8876  xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8877  world coordinates).\n\
8878 \n\
8879  ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8880  coordinates).\n\
8881 \n\
8882  ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8883  coordinates).\n\
8884 \n\
8885  just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8886  scales will not be set, the user must set up the scale before\n\
8887  calling plenv using plsvpa, plvasp or other.\n\
8888  0: the x and y axes are scaled independently to use as much of\n\
8889  the screen as possible.\n\
8890  1: the scales of the x and y axes are made equal.\n\
8891  2: the axis of the x and y axes are made equal, and the plot\n\
8892  box will be square.\n\
8893 \n\
8894 \n\
8895  axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8896  -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
8897  -1: draw box only.\n\
8898  0: draw box, ticks, and numeric tick labels.\n\
8899  1: also draw coordinate axes at x=0 and y=0.\n\
8900  2: also draw a grid at major tick positions in both\n\
8901  coordinates.\n\
8902  3: also draw a grid at minor tick positions in both\n\
8903  coordinates.\n\
8904  10: same as 0 except logarithmic x tick marks. (The x data\n\
8905  have to be converted to logarithms separately.)\n\
8906  11: same as 1 except logarithmic x tick marks. (The x data\n\
8907  have to be converted to logarithms separately.)\n\
8908  12: same as 2 except logarithmic x tick marks. (The x data\n\
8909  have to be converted to logarithms separately.)\n\
8910  13: same as 3 except logarithmic x tick marks. (The x data\n\
8911  have to be converted to logarithms separately.)\n\
8912  20: same as 0 except logarithmic y tick marks. (The y data\n\
8913  have to be converted to logarithms separately.)\n\
8914  21: same as 1 except logarithmic y tick marks. (The y data\n\
8915  have to be converted to logarithms separately.)\n\
8916  22: same as 2 except logarithmic y tick marks. (The y data\n\
8917  have to be converted to logarithms separately.)\n\
8918  23: same as 3 except logarithmic y tick marks. (The y data\n\
8919  have to be converted to logarithms separately.)\n\
8920  30: same as 0 except logarithmic x and y tick marks. (The x\n\
8921  and y data have to be converted to logarithms separately.)\n\
8922  31: same as 1 except logarithmic x and y tick marks. (The x\n\
8923  and y data have to be converted to logarithms separately.)\n\
8924  32: same as 2 except logarithmic x and y tick marks. (The x\n\
8925  and y data have to be converted to logarithms separately.)\n\
8926  33: same as 3 except logarithmic x and y tick marks. (The x\n\
8927  and y data have to be converted to logarithms separately.)\n\
8928  40: same as 0 except date / time x labels.\n\
8929  41: same as 1 except date / time x labels.\n\
8930  42: same as 2 except date / time x labels.\n\
8931  43: same as 3 except date / time x labels.\n\
8932  50: same as 0 except date / time y labels.\n\
8933  51: same as 1 except date / time y labels.\n\
8934  52: same as 2 except date / time y labels.\n\
8935  53: same as 3 except date / time y labels.\n\
8936  60: same as 0 except date / time x and y labels.\n\
8937  61: same as 1 except date / time x and y labels.\n\
8938  62: same as 2 except date / time x and y labels.\n\
8939  63: same as 3 except date / time x and y labels.\n\
8940  70: same as 0 except custom x and y labels.\n\
8941  71: same as 1 except custom x and y labels.\n\
8942  72: same as 2 except custom x and y labels.\n\
8943  73: same as 3 except custom x and y labels.\n\
8944 ";
8945 static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
8946 Grid data from irregularly sampled data\n\
8947 \n\
8948 DESCRIPTION:\n\
8949 \n\
8950  Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
8951  require data organized as a grid, i.e., with x sample point values\n\
8952  independent of y coordinate and vice versa. This function takes\n\
8953  irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
8954  vectors; reads the desired grid location from the input vectors\n\
8955  xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
8956  grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
8957  interpolate the data to the grid is specified with the argument type\n\
8958  which can have one parameter specified in argument data.\n\
8959 \n\
8960  Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8961  Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8962 \n\
8963 \n\
8964  This function is used in example 21.\n\
8965 \n\
8966 \n\
8967 \n\
8968 SYNOPSIS:\n\
8969 \n\
8970 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8971 \n\
8972 ARGUMENTS:\n\
8973 \n\
8974  x (PLFLT_VECTOR, input) : The input x vector.\n\
8975 \n\
8976  y (PLFLT_VECTOR, input) : The input y vector.\n\
8977 \n\
8978  z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
8979  y[i], z[i] represents one data sample coordinate.\n\
8980 \n\
8981  npts (PLINT, input) : The number of data samples in the x, y and z\n\
8982  vectors.\n\
8983 \n\
8984  xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8985  in the x direction. Usually xg has nptsx equally spaced values\n\
8986  from the minimum to the maximum values of the x input vector.\n\
8987 \n\
8988  nptsx (PLINT, input) : The number of points in the xg vector.\n\
8989 \n\
8990  yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8991  in the y direction. Similar to the xg parameter.\n\
8992 \n\
8993  nptsy (PLINT, input) : The number of points in the yg vector.\n\
8994 \n\
8995  zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
8996  where data lies in the grid specified by xg and yg. Therefore the\n\
8997  zg matrix must be dimensioned\n\
8998  nptsx by\n\
8999  nptsy.\n\
9000 \n\
9001  type (PLINT, input) : The type of grid interpolation algorithm to\n\
9002  use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
9003  GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
9004  GRID_NNI: Natural Neighbors Interpolation\n\
9005  GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
9006  GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
9007  GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
9008  Weighted\n\
9009  For details of the algorithms read the source file plgridd.c.\n\
9010 \n\
9011  data (PLFLT, input) : Some gridding algorithms require extra data,\n\
9012  which can be specified through this argument. Currently, for\n\
9013  algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
9014  use, the lower the value, the noisier (more local) the\n\
9015  approximation is.\n\
9016  GRID_NNLI, data specifies what a thin triangle is, in the\n\
9017  range [1. .. 2.]. High values enable the usage of very thin\n\
9018  triangles for interpolation, possibly resulting in error in\n\
9019  the approximation.\n\
9020  GRID_NNI, only weights greater than data will be accepted. If\n\
9021  0, all weights will be accepted.\n\
9022 ";
9023 static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
9024 Clear current (sub)page\n\
9025 \n\
9026 DESCRIPTION:\n\
9027 \n\
9028  Clears the current page, effectively erasing everything that have been\n\
9029  drawn. This command only works with interactive drivers; if the\n\
9030  driver does not support this, the page is filled with the background\n\
9031  color in use. If the current page is divided into subpages, only the\n\
9032  current subpage is erased. The nth subpage can be selected with\n\
9033  pladv(n).\n\
9034 \n\
9035  Redacted form: General: plclear()\n\
9036 \n\
9037 \n\
9038  This function is not used in any examples.\n\
9039 \n\
9040 \n\
9041 \n\
9042 SYNOPSIS:\n\
9043 \n\
9044 plclear()\n\
9045 ";
9046 static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
9047 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
9048 \n\
9049 DESCRIPTION:\n\
9050 \n\
9051  Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
9052  and PLFLT alpha transparency value. This sets the entire color map --\n\
9053  only as many colors as specified will be allocated.\n\
9054 \n\
9055  Redacted form: plscmap0a(r, g, b, alpha)\n\
9056 \n\
9057  This function is used in examples 30.\n\
9058 \n\
9059 \n\
9060 \n\
9061 SYNOPSIS:\n\
9062 \n\
9063 plscmap0a(r, g, b, alpha, ncol0)\n\
9064 \n\
9065 ARGUMENTS:\n\
9066 \n\
9067  r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9068  integers (0-255) representing the degree of red in the color.\n\
9069 \n\
9070  g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9071  integers (0-255) representing the degree of green in the color.\n\
9072 \n\
9073  b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9074  integers (0-255) representing the degree of blue in the color.\n\
9075 \n\
9076  alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
9077  representing the alpha transparency of the color.\n\
9078 \n\
9079  ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9080  vectors.\n\
9081 ";
9082 static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
9083 Set 8-bit RGB values for given cmap0 color index\n\
9084 \n\
9085 DESCRIPTION:\n\
9086 \n\
9087  Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
9088  index. Overwrites the previous color value for the given index and,\n\
9089  thus, does not result in any additional allocation of space for\n\
9090  colors.\n\
9091 \n\
9092  Redacted form: plscol0(icol0, r, g, b)\n\
9093 \n\
9094  This function is used in any example 31.\n\
9095 \n\
9096 \n\
9097 \n\
9098 SYNOPSIS:\n\
9099 \n\
9100 plscol0(icol0, r, g, b)\n\
9101 \n\
9102 ARGUMENTS:\n\
9103 \n\
9104  icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
9105  number of colors (which is set by default, by plscmap0n, or even\n\
9106  by plscmap0).\n\
9107 \n\
9108  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9109  degree of red in the color.\n\
9110 \n\
9111  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9112  degree of green in the color.\n\
9113 \n\
9114  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9115  degree of blue in the color.\n\
9116 ";
9117 static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
9118 Set up transformation from metafile coordinates\n\
9119 \n\
9120 DESCRIPTION:\n\
9121 \n\
9122  Set up transformation from metafile coordinates. The size of the plot\n\
9123  is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
9124  general-purpose facility just yet (not sure why the user would need\n\
9125  it, for one).\n\
9126 \n\
9127  Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
9128  dimypmm)\n\
9129 \n\
9130  This function is not used in any examples.\n\
9131 \n\
9132 \n\
9133 \n\
9134 SYNOPSIS:\n\
9135 \n\
9136 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
9137 \n\
9138 ARGUMENTS:\n\
9139 \n\
9140  dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
9141 \n\
9142  dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
9143 \n\
9144  dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
9145 \n\
9146  dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
9147 \n\
9148  dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9149 \n\
9150  dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9151 ";
9152 static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
9153 Creates a new stream and makes it the default\n\
9154 \n\
9155 DESCRIPTION:\n\
9156 \n\
9157  Creates a new stream and makes it the default. Differs from using\n\
9158  plsstrm, in that a free stream number is found, and returned.\n\
9159  Unfortunately, I have to start at stream 1 and work upward, since\n\
9160  stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
9161  that no initial, library-opening call is required. So stream 0 must\n\
9162  be preallocated, and there is no simple way of determining whether it\n\
9163  is already in use or not.\n\
9164 \n\
9165  Redacted form: plmkstrm(p_strm)\n\
9166 \n\
9167  This function is used in examples 1 and 20.\n\
9168 \n\
9169 \n\
9170 \n\
9171 SYNOPSIS:\n\
9172 \n\
9173 plmkstrm(p_strm)\n\
9174 \n\
9175 ARGUMENTS:\n\
9176 \n\
9177  p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
9178  number of the created stream.\n\
9179 ";
9180 static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
9181 Get page parameters\n\
9182 \n\
9183 DESCRIPTION:\n\
9184 \n\
9185  Gets the current page configuration. The length and offset values are\n\
9186  expressed in units that are specific to the current driver. For\n\
9187  instance: screen drivers will usually interpret them as number of\n\
9188  pixels, whereas printer drivers will usually use mm.\n\
9189 \n\
9190  Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9191 \n\
9192  This function is used in examples 14 and 31.\n\
9193 \n\
9194 \n\
9195 \n\
9196 SYNOPSIS:\n\
9197 \n\
9198 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9199 \n\
9200 ARGUMENTS:\n\
9201 \n\
9202  p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9203  pixels/inch (DPI) in x.\n\
9204 \n\
9205  p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9206  pixels/inch (DPI) in y.\n\
9207 \n\
9208  p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9209  length.\n\
9210 \n\
9211  p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9212  length.\n\
9213 \n\
9214  p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9215  offset.\n\
9216 \n\
9217  p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9218  offset.\n\
9219 ";
9220 static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
9221 Set format for date / time labels\n\
9222 \n\
9223 DESCRIPTION:\n\
9224 \n\
9225  Sets the format for date / time labels. To enable date / time format\n\
9226  labels see the options to plbox, plbox3, and plenv.\n\
9227 \n\
9228  Redacted form: pltimefmt(fmt)\n\
9229 \n\
9230  This function is used in example 29.\n\
9231 \n\
9232 \n\
9233 \n\
9234 SYNOPSIS:\n\
9235 \n\
9236 pltimefmt(fmt)\n\
9237 \n\
9238 ARGUMENTS:\n\
9239 \n\
9240  fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
9241  interpreted similarly to the format specifier of typical system\n\
9242  strftime routines except that PLplot ignores locale and also\n\
9243  supplies some useful extensions in the context of plotting. All\n\
9244  text in the string is printed as-is other than conversion\n\
9245  specifications which take the form of a \'%\' character followed by\n\
9246  further conversion specification character. The conversion\n\
9247  specifications which are similar to those provided by system\n\
9248  strftime routines are the following: %a: The abbreviated (English)\n\
9249  weekday name.\n\
9250  %A: The full (English) weekday name.\n\
9251  %b: The abbreviated (English) month name.\n\
9252  %B: The full (English) month name.\n\
9253  %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
9254  %C: The century number (year/100) as a 2-digit integer.\n\
9255  %d: The day of the month as a decimal number (range 01 to 31).\n\
9256  %D: Equivalent to %m/%d/%y (non-ISO).\n\
9257  %e: Like %d, but a leading zero is replaced by a space.\n\
9258  %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
9259  %h: Equivalent to %b.\n\
9260  %H: The hour as a decimal number using a 24-hour clock (range\n\
9261  00 to 23).\n\
9262  %I: The hour as a decimal number using a 12-hour clock (range\n\
9263  01 to 12).\n\
9264  %j: The day of the year as a decimal number (range 001 to\n\
9265  366).\n\
9266  %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
9267  23); single digits are preceded by a blank. (See also %H.)\n\
9268  %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
9269  12); single digits are preceded by a blank. (See also %I.)\n\
9270  %m: The month as a decimal number (range 01 to 12).\n\
9271  %M: The minute as a decimal number (range 00 to 59).\n\
9272  %n: A newline character.\n\
9273  %p: Either \"AM\" or \"PM\" according to the given time value.\n\
9274  Noon is treated as \"PM\" and midnight as \"AM\".\n\
9275  %r: Equivalent to %I:%M:%S %p.\n\
9276  %R: The time in 24-hour notation (%H:%M). For a version\n\
9277  including the seconds, see %T below.\n\
9278  %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
9279  +0000 (UTC).\n\
9280  %S: The second as a decimal number (range 00 to 60). (The\n\
9281  range is up to 60 to allow for occasional leap seconds.)\n\
9282  %t: A tab character.\n\
9283  %T: The time in 24-hour notation (%H:%M:%S).\n\
9284  %u: The day of the week as a decimal, range 1 to 7, Monday\n\
9285  being 1. See also %w.\n\
9286  %U: The week number of the current year as a decimal number,\n\
9287  range 00 to 53, starting with the first Sunday as the first\n\
9288  day of week 01. See also %V and %W.\n\
9289  %v: Equivalent to %e-%b-%Y.\n\
9290  %V: The ISO 8601 week number of the current year as a decimal\n\
9291  number, range 01 to 53, where week 1 is the first week that\n\
9292  has at least 4 days in the new year. See also %U and %W.\n\
9293  %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
9294  being 0. See also %u.\n\
9295  %W: The week number of the current year as a decimal number,\n\
9296  range 00 to 53, starting with the first Monday as the first\n\
9297  day of week 01.\n\
9298  %x: Equivalent to %a %b %d %Y.\n\
9299  %X: Equivalent to %T.\n\
9300  %y: The year as a decimal number without a century (range 00\n\
9301  to 99).\n\
9302  %Y: The year as a decimal number including a century.\n\
9303  %z: The UTC time-zone string = \"+0000\".\n\
9304  %Z: The UTC time-zone abbreviation = \"UTC\".\n\
9305  %+: The UTC date and time in default format of the Unix date\n\
9306  command which is equivalent to %a %b %d %T %Z %Y.\n\
9307  %%: A literal \"%\" character.\n\
9308  The conversion specifications which are extensions to those normally\n\
9309  provided by system strftime routines are the following: %(0-9):\n\
9310  The fractional part of the seconds field (including leading\n\
9311  decimal point) to the specified accuracy. Thus %S%3 would give\n\
9312  seconds to millisecond accuracy (00.000).\n\
9313  %.: The fractional part of the seconds field (including\n\
9314  leading decimal point) to the maximum available accuracy. Thus\n\
9315  %S%. would give seconds with fractional part up to 9 decimal\n\
9316  places if available.\n\
9317 ";
9318 static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
9319 Specify viewport using aspect ratio only\n\
9320 \n\
9321 DESCRIPTION:\n\
9322 \n\
9323  Selects the largest viewport with the given aspect ratio within the\n\
9324  subpage that leaves a standard margin (left-hand margin of eight\n\
9325  character heights, and a margin around the other three sides of five\n\
9326  character heights).\n\
9327 \n\
9328  Redacted form: plvasp(aspect)\n\
9329 \n\
9330  This function is used in example 13.\n\
9331 \n\
9332 \n\
9333 \n\
9334 SYNOPSIS:\n\
9335 \n\
9336 plvasp(aspect)\n\
9337 \n\
9338 ARGUMENTS:\n\
9339 \n\
9340  aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9341  axis of resulting viewport.\n\
9342 ";
9343 static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
9344 Set output file name\n\
9345 \n\
9346 DESCRIPTION:\n\
9347 \n\
9348  Sets the current output file name, if applicable. If the file name\n\
9349  has not been specified and is required by the driver, the user will be\n\
9350  prompted for it. If using the X-windows output driver, this sets the\n\
9351  display name. This routine, if used, must be called before\n\
9352  initializing PLplot.\n\
9353 \n\
9354  Redacted form: plsfnam(fnam)\n\
9355 \n\
9356  This function is used in examples 1 and 20.\n\
9357 \n\
9358 \n\
9359 \n\
9360 SYNOPSIS:\n\
9361 \n\
9362 plsfnam(fnam)\n\
9363 \n\
9364 ARGUMENTS:\n\
9365 \n\
9366  fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9367  the file name.\n\
9368 ";
9369 static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
9370 Vector plot\n\
9371 \n\
9372 DESCRIPTION:\n\
9373 \n\
9374  Draws a plot of vector data contained in the matrices (\n\
9375  u[\n\
9376  nx][\n\
9377  ny],\n\
9378  v[\n\
9379  nx][\n\
9380  ny]) . The scaling factor for the vectors is given by scale. A\n\
9381  transformation routine pointed to by pltr with a pointer pltr_data for\n\
9382  additional data required by the transformation routine to map indices\n\
9383  within the matrices to the world coordinates. The style of the vector\n\
9384  arrow may be set using plsvect.\n\
9385 \n\
9386  Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9387  discussion) the pltr, pltr_data callback arguments are sometimes\n\
9388  replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9389  with either one or two dimensions.\n\
9390 \n\
9391  This function is used in example 22.\n\
9392 \n\
9393 \n\
9394 \n\
9395 SYNOPSIS:\n\
9396 \n\
9397 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9398 \n\
9399 ARGUMENTS:\n\
9400 \n\
9401  u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9402  and y components of the vector data to be plotted.\n\
9403 \n\
9404  nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9405 \n\
9406  scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9407  the vectors for plotting. If scale = 0 then the scaling factor is\n\
9408  automatically calculated for the data. If scale < 0 then the\n\
9409  scaling factor is automatically calculated for the data and then\n\
9410  multiplied by -\n\
9411  scale. If scale > 0 then the scaling factor is set to scale.\n\
9412 \n\
9413  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9414  defines the transformation between the zero-based indices of the\n\
9415  matrices u and v and world coordinates.For the C case,\n\
9416  transformation functions are provided in the PLplot library: pltr0\n\
9417  for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9418  mappings respectively defined by vectors and matrices. In\n\
9419  addition, C callback routines for the transformation can be\n\
9420  supplied by the user such as the mypltr function in\n\
9421  examples/c/x09c.c which provides a general linear transformation\n\
9422  between index coordinates and world coordinates.For languages\n\
9423  other than C you should consult the PLplot documentation for the\n\
9424  details concerning how PLTRANSFORM_callback arguments are\n\
9425  interfaced. However, in general, a particular pattern of\n\
9426  callback-associated arguments such as a tr vector with 6 elements;\n\
9427  xg and yg vectors; or xg and yg matrices are respectively\n\
9428  interfaced to a linear-transformation routine similar to the above\n\
9429  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9430  sophisticated bindings (see, e.g., the PLplot documentation)\n\
9431  support native language callbacks for handling index to\n\
9432  world-coordinate transformations. Examples of these various\n\
9433  approaches are given in examples/<language>x09*,\n\
9434  examples/<language>x16*, examples/<language>x20*,\n\
9435  examples/<language>x21*, and examples/<language>x22*, for all our\n\
9436  supported languages.\n\
9437 \n\
9438  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9439  information to pltr0, pltr1, pltr2, or whatever callback routine\n\
9440  that is externally supplied.\n\
9441 ";
9442 static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
9443 Set parameters that define current plot-space window\n\
9444 \n\
9445 DESCRIPTION:\n\
9446 \n\
9447  Set relative minima and maxima that define the current plot-space\n\
9448  window. If plsdiplt is not called the default values of xmin, ymin,\n\
9449  xmax, and ymax are 0., 0., 1., and 1.\n\
9450 \n\
9451  Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9452 \n\
9453  This function is used in example 31.\n\
9454 \n\
9455 \n\
9456 \n\
9457 SYNOPSIS:\n\
9458 \n\
9459 plsdiplt(xmin, ymin, xmax, ymax)\n\
9460 \n\
9461 ARGUMENTS:\n\
9462 \n\
9463  xmin (PLFLT, input) : Relative minimum in x.\n\
9464 \n\
9465  ymin (PLFLT, input) : Relative minimum in y.\n\
9466 \n\
9467  xmax (PLFLT, input) : Relative maximum in x.\n\
9468 \n\
9469  ymax (PLFLT, input) : Relative maximum in y.\n\
9470 ";
9471 static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
9472 Select line style\n\
9473 \n\
9474 DESCRIPTION:\n\
9475 \n\
9476  This sets the line style according to one of eight predefined patterns\n\
9477  (also see plstyl).\n\
9478 \n\
9479  Redacted form: pllsty(lin)\n\
9480 \n\
9481  This function is used in examples 9, 12, 22, and 25.\n\
9482 \n\
9483 \n\
9484 \n\
9485 SYNOPSIS:\n\
9486 \n\
9487 pllsty(lin)\n\
9488 \n\
9489 ARGUMENTS:\n\
9490 \n\
9491  lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9492  a continuous line, line style 2 is a line with short dashes and\n\
9493  gaps, line style 3 is a line with long dashes and gaps, line style\n\
9494  4 has long dashes and short gaps and so on.\n\
9495 ";
9496 static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
9497 Plot a glyph at the specified points\n\
9498 \n\
9499 DESCRIPTION:\n\
9500 \n\
9501  Plot a glyph at the specified points. (This function is largely\n\
9502  superseded by plstring which gives access to many[!] more glyphs.)\n\
9503 \n\
9504  Redacted form: plsym(x, y, code)\n\
9505 \n\
9506  This function is used in example 7.\n\
9507 \n\
9508 \n\
9509 \n\
9510 SYNOPSIS:\n\
9511 \n\
9512 plsym(n, x, y, code)\n\
9513 \n\
9514 ARGUMENTS:\n\
9515 \n\
9516  n (PLINT, input) : Number of points in the x and y vectors.\n\
9517 \n\
9518  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9519  the points.\n\
9520 \n\
9521  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9522  the points.\n\
9523 \n\
9524  code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9525  to be plotted at each of the n points.\n\
9526 ";
9527 static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
9528 Set the device (keyword) name\n\
9529 \n\
9530 DESCRIPTION:\n\
9531 \n\
9532  Set the device (keyword) name.\n\
9533 \n\
9534  Redacted form: plsdev(devname)\n\
9535 \n\
9536  This function is used in examples 1, 14, and 20.\n\
9537 \n\
9538 \n\
9539 \n\
9540 SYNOPSIS:\n\
9541 \n\
9542 plsdev(devname)\n\
9543 \n\
9544 ARGUMENTS:\n\
9545 \n\
9546  devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9547  containing the device name keyword of the required output device.\n\
9548  If\n\
9549  devname is NULL or if the first character of the string is a ``?\'\',\n\
9550  the normal (prompted) start up is used.\n\
9551 ";
9552 static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
9553 Set the background color by 8-bit RGB value\n\
9554 \n\
9555 DESCRIPTION:\n\
9556 \n\
9557  Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9558  the PLplot documentation).\n\
9559 \n\
9560  Redacted form: plscolbg(r, g, b)\n\
9561 \n\
9562  This function is used in examples 15 and 31.\n\
9563 \n\
9564 \n\
9565 \n\
9566 SYNOPSIS:\n\
9567 \n\
9568 plscolbg(r, g, b)\n\
9569 \n\
9570 ARGUMENTS:\n\
9571 \n\
9572  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9573  degree of red in the color.\n\
9574 \n\
9575  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9576  degree of green in the color.\n\
9577 \n\
9578  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9579  degree of blue in the color.\n\
9580 ";
9581 static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
9582 Set parameters incrementally (zoom mode) that define current plot-space window\n\
9583 \n\
9584 DESCRIPTION:\n\
9585 \n\
9586  Set relative minima and maxima incrementally (zoom mode) that define\n\
9587  the current plot-space window. This function has the same effect as\n\
9588  plsdiplt if that function has not been previously called. Otherwise,\n\
9589  this function implements zoom mode using the transformation min_used =\n\
9590  old_min + old_length*min and max_used = old_min + old_length*max for\n\
9591  each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
9592  repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9593 \n\
9594  Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9595 \n\
9596  This function is used in example 31.\n\
9597 \n\
9598 \n\
9599 \n\
9600 SYNOPSIS:\n\
9601 \n\
9602 plsdiplz(xmin, ymin, xmax, ymax)\n\
9603 \n\
9604 ARGUMENTS:\n\
9605 \n\
9606  xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9607 \n\
9608  ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9609 \n\
9610  xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9611 \n\
9612  ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9613 ";
9614 static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
9615 Advance to the next family file on the next new page\n\
9616 \n\
9617 DESCRIPTION:\n\
9618 \n\
9619  Advance to the next family file on the next new page.\n\
9620 \n\
9621  Redacted form: plfamadv()\n\
9622 \n\
9623  This function is not used in any examples.\n\
9624 \n\
9625 \n\
9626 \n\
9627 SYNOPSIS:\n\
9628 \n\
9629 plfamadv()\n\
9630 ";
9631 static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9632 Set number of colors in cmap0\n\
9633 \n\
9634 DESCRIPTION:\n\
9635 \n\
9636  Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9637  (or reallocate) cmap0, and fill with default values for those colors\n\
9638  not previously allocated. The first 16 default colors are given in\n\
9639  the plcol0 documentation. For larger indices the default color is\n\
9640  red.\n\
9641 \n\
9642  The drivers are not guaranteed to support more than 16 colors.\n\
9643 \n\
9644  Redacted form: plscmap0n(ncol0)\n\
9645 \n\
9646  This function is used in examples 15, 16, and 24.\n\
9647 \n\
9648 \n\
9649 \n\
9650 SYNOPSIS:\n\
9651 \n\
9652 plscmap0n(ncol0)\n\
9653 \n\
9654 ARGUMENTS:\n\
9655 \n\
9656  ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9657  the cmap0 palette. If this number is zero or less, then the value\n\
9658  from the previous call to plscmap0n is used and if there is no\n\
9659  previous call, then a default value is used.\n\
9660 ";
9661 static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
9662 Plot latitude and longitude lines\n\
9663 \n\
9664 DESCRIPTION:\n\
9665 \n\
9666  Displays latitude and longitude on the current plot. The lines are\n\
9667  plotted in the current color and line style.\n\
9668 \n\
9669  Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9670  minlat, maxlat)\n\
9671 \n\
9672  This function is used in example 19.\n\
9673 \n\
9674 \n\
9675 \n\
9676 SYNOPSIS:\n\
9677 \n\
9678 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9679 \n\
9680 ARGUMENTS:\n\
9681 \n\
9682  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9683  transform the coordinate longitudes and latitudes to a plot\n\
9684  coordinate system. By using this transform, we can change from a\n\
9685  longitude, latitude coordinate to a polar stereographic project,\n\
9686  for example. Initially, x[0]..[n-1] are the longitudes and\n\
9687  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9688  mapform(), x[] and y[] should be replaced by the corresponding\n\
9689  plot coordinates. If no transform is desired, mapform can be\n\
9690  replaced by NULL.\n\
9691 \n\
9692  dlong (PLFLT, input) : The interval in degrees at which the\n\
9693  longitude lines are to be plotted.\n\
9694 \n\
9695  dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9696  lines are to be plotted.\n\
9697 \n\
9698  minlong (PLFLT, input) : The value of the longitude on the left\n\
9699  side of the plot. The value of minlong must be less than the value\n\
9700  of maxlong, and the quantity maxlong-minlong must be less than or\n\
9701  equal to 360.\n\
9702 \n\
9703  maxlong (PLFLT, input) : The value of the longitude on the right\n\
9704  side of the plot.\n\
9705 \n\
9706  minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9707  background. One can always use -90.0 as the boundary outside the\n\
9708  plot window will be automatically eliminated. However, the\n\
9709  program will be faster if one can reduce the size of the\n\
9710  background plotted.\n\
9711 \n\
9712  maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9713  background. One can always use 90.0 as the boundary outside the\n\
9714  plot window will be automatically eliminated.\n\
9715 ";
9716 static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9717 Convert RGB color to HLS\n\
9718 \n\
9719 DESCRIPTION:\n\
9720 \n\
9721  Convert RGB color coordinates to HLS\n\
9722 \n\
9723  Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9724 \n\
9725 \n\
9726  This function is used in example 2.\n\
9727 \n\
9728 \n\
9729 \n\
9730 SYNOPSIS:\n\
9731 \n\
9732 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9733 \n\
9734 ARGUMENTS:\n\
9735 \n\
9736  r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9737 \n\
9738  g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9739 \n\
9740  b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9741 \n\
9742  p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9743  degrees (0.0-360.0) on the color cylinder.\n\
9744 \n\
9745  p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9746  expressed as a fraction (0.0-1.0) of the axis of the color\n\
9747  cylinder.\n\
9748 \n\
9749  p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9750  expressed as a fraction (0.0-1.0) of the radius of the color\n\
9751  cylinder.\n\
9752 ";
9753 static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
9754 Plot a glyph at the specified 3D points\n\
9755 \n\
9756 DESCRIPTION:\n\
9757 \n\
9758  Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9759  many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9760  this function similar to what is done for plline3. The glyph is\n\
9761  specified with a PLplot user string. Note that the user string is not\n\
9762  actually limited to one glyph so it is possible (but not normally\n\
9763  useful) to plot more than one glyph at the specified points with this\n\
9764  function. As with plmtex and plptex, the user string can contain FCI\n\
9765  escapes to determine the font, UTF-8 code to determine the glyph or\n\
9766  else PLplot escapes for Hershey or unicode text to determine the\n\
9767  glyph.\n\
9768 \n\
9769  Redacted form: plstring3(x, y, z, string)\n\
9770 \n\
9771  This function is used in example 18.\n\
9772 \n\
9773 \n\
9774 \n\
9775 SYNOPSIS:\n\
9776 \n\
9777 plstring3(n, x, y, z, string)\n\
9778 \n\
9779 ARGUMENTS:\n\
9780 \n\
9781  n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9782 \n\
9783  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9784  the points.\n\
9785 \n\
9786  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9787  the points.\n\
9788 \n\
9789  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9790  the points.\n\
9791 \n\
9792  string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9793  the glyph(s) to be plotted at each of the n points. points.\n\
9794 ";
9795 static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
9796 Switch to text screen\n\
9797 \n\
9798 DESCRIPTION:\n\
9799 \n\
9800  Sets an interactive device to text mode, used in conjunction with\n\
9801  plgra to allow graphics and text to be interspersed. On a device\n\
9802  which supports separate text and graphics windows, this command causes\n\
9803  control to be switched to the text window. This can be useful for\n\
9804  printing diagnostic messages or getting user input, which would\n\
9805  otherwise interfere with the plots. The program must switch back to\n\
9806  the graphics window before issuing plot commands, as the text (or\n\
9807  console) device will probably become quite confused otherwise. If\n\
9808  already in text mode, this command is ignored. It is also ignored on\n\
9809  devices which only support a single window or use a different method\n\
9810  for shifting focus (see also plgra).\n\
9811 \n\
9812  Redacted form: pltext()\n\
9813 \n\
9814  This function is used in example 1.\n\
9815 \n\
9816 \n\
9817 \n\
9818 SYNOPSIS:\n\
9819 \n\
9820 pltext()\n\
9821 ";
9822 static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
9823 Get parameters that define current plot-space window\n\
9824 \n\
9825 DESCRIPTION:\n\
9826 \n\
9827  Get relative minima and maxima that define current plot-space window.\n\
9828  If plsdiplt has not been called the default values pointed to by\n\
9829  p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9830 \n\
9831  Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9832 \n\
9833  This function is used in example 31.\n\
9834 \n\
9835 \n\
9836 \n\
9837 SYNOPSIS:\n\
9838 \n\
9839 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9840 \n\
9841 ARGUMENTS:\n\
9842 \n\
9843  p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9844  minimum in x.\n\
9845 \n\
9846  p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9847  minimum in y.\n\
9848 \n\
9849  p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9850  maximum in x.\n\
9851 \n\
9852  p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9853  maximum in y.\n\
9854 ";
9855 static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
9856 Get the (current) run level\n\
9857 \n\
9858 DESCRIPTION:\n\
9859 \n\
9860  Get the (current) run level. Valid settings are: 0, uninitialized\n\
9861  1, initialized\n\
9862  2, viewport defined\n\
9863  3, world coordinates defined\n\
9864 \n\
9865 \n\
9866  Redacted form: plglevel(p_level)\n\
9867 \n\
9868  This function is used in example 31.\n\
9869 \n\
9870 \n\
9871 \n\
9872 SYNOPSIS:\n\
9873 \n\
9874 plglevel(p_level)\n\
9875 \n\
9876 ARGUMENTS:\n\
9877 \n\
9878  p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9879  level.\n\
9880 ";
9881 static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
9882 Plot a histogram from binned data\n\
9883 \n\
9884 DESCRIPTION:\n\
9885 \n\
9886  Plots a histogram consisting of nbin bins. The value associated with\n\
9887  the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9888  placed in y[i]. For proper operation, the values in x[i] must form a\n\
9889  strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9890  of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9891  placed midway between the values in the x vector. Also see plhist for\n\
9892  drawing histograms from unbinned data.\n\
9893 \n\
9894  Redacted form: General: plbin(x, y, opt)\n\
9895  Python: plbin(nbin, x, y, opt)\n\
9896 \n\
9897 \n\
9898  This function is not used in any examples.\n\
9899 \n\
9900 \n\
9901 \n\
9902 SYNOPSIS:\n\
9903 \n\
9904 plbin(nbin, x, y, opt)\n\
9905 \n\
9906 ARGUMENTS:\n\
9907 \n\
9908  nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9909  and y vectors.)\n\
9910 \n\
9911  x (PLFLT_VECTOR, input) : A vector containing values associated\n\
9912  with bins. These must form a strictly increasing sequence.\n\
9913 \n\
9914  y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
9915  proportional to the number of points in each bin. This is a PLFLT\n\
9916  (instead of PLINT) vector so as to allow histograms of\n\
9917  probabilities, etc.\n\
9918 \n\
9919  opt (PLINT, input) : Is a combination of several flags:\n\
9920  opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9921  outer bins are expanded to fill up the entire x-axis and bins of\n\
9922  zero height are simply drawn.\n\
9923  opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9924  between the x values. If the values in x are equally spaced,\n\
9925  the values are the center values of the bins.\n\
9926  opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9927  size as the ones inside.\n\
9928  opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9929  (there is a gap for such bins).\n\
9930 ";
9931 static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
9932 Plot a 2D matrix using cmap1\n\
9933 \n\
9934 DESCRIPTION:\n\
9935 \n\
9936  Plot a 2D matrix using cmap1.\n\
9937 \n\
9938  Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
9939  zmax, valuemin, valuemax, pltr, pltr_data)\n\
9940 \n\
9941 \n\
9942  This function is used in example 20.\n\
9943 \n\
9944 \n\
9945 \n\
9946 SYNOPSIS:\n\
9947 \n\
9948 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9949 \n\
9950 ARGUMENTS:\n\
9951 \n\
9952  idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
9953  plot. Should have dimensions of\n\
9954  nx by\n\
9955  ny.\n\
9956 \n\
9957  nx, ny (PLINT, input) : Dimensions of idata\n\
9958 \n\
9959  xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
9960  pltr below for how these arguments are used (only for the special case\n\
9961  when the callback function\n\
9962  pltr is not supplied).\n\
9963 \n\
9964  zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9965  (inclusive) will be plotted.\n\
9966 \n\
9967  valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9968  values to use for value to color mappings. A datum equal to or\n\
9969  less than valuemin will be plotted with color 0.0, while a datum\n\
9970  equal to or greater than valuemax will be plotted with color 1.0.\n\
9971  Data between valuemin and valuemax map linearly to colors in the\n\
9972  range (0.0-1.0).\n\
9973 \n\
9974  pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9975  defines the transformation between the zero-based indices of the\n\
9976  matrix idata and world coordinates. If\n\
9977  pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
9978  indices of idata are mapped to the range\n\
9979  xmin through\n\
9980  xmax and the y indices of idata are mapped to the range\n\
9981  ymin through\n\
9982  ymax.For the C case, transformation functions are provided in the\n\
9983  PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
9984  pltr2 for arbitrary mappings respectively defined by vectors and\n\
9985  matrices. In addition, C callback routines for the transformation\n\
9986  can be supplied by the user such as the mypltr function in\n\
9987  examples/c/x09c.c which provides a general linear transformation\n\
9988  between index coordinates and world coordinates.For languages\n\
9989  other than C you should consult the PLplot documentation for the\n\
9990  details concerning how PLTRANSFORM_callback arguments are\n\
9991  interfaced. However, in general, a particular pattern of\n\
9992  callback-associated arguments such as a tr vector with 6 elements;\n\
9993  xg and yg vectors; or xg and yg matrices are respectively\n\
9994  interfaced to a linear-transformation routine similar to the above\n\
9995  mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9996  sophisticated bindings (see, e.g., the PLplot documentation)\n\
9997  support native language callbacks for handling index to\n\
9998  world-coordinate transformations. Examples of these various\n\
9999  approaches are given in examples/<language>x09*,\n\
10000  examples/<language>x16*, examples/<language>x20*,\n\
10001  examples/<language>x21*, and examples/<language>x22*, for all our\n\
10002  supported languages.\n\
10003 \n\
10004  pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10005  information to pltr0, pltr1, pltr2, or whatever routine is\n\
10006  externally supplied.\n\
10007 ";
10008 static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
10009 Get family, style and weight of the current font\n\
10010 \n\
10011 DESCRIPTION:\n\
10012 \n\
10013  Gets information about current font. See the PLplot documentation for\n\
10014  more information on font selection.\n\
10015 \n\
10016  Redacted form: plgfont(p_family, p_style, p_weight)\n\
10017 \n\
10018  This function is used in example 23.\n\
10019 \n\
10020 \n\
10021 \n\
10022 SYNOPSIS:\n\
10023 \n\
10024 plgfont(p_family, p_style, p_weight)\n\
10025 \n\
10026 ARGUMENTS:\n\
10027 \n\
10028  p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10029  font family. The available values are given by the PL_FCI_*\n\
10030  constants in plplot.h. Current options are PL_FCI_SANS,\n\
10031  PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
10032  p_family is NULL then the font family is not returned.\n\
10033 \n\
10034  p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10035  font style. The available values are given by the PL_FCI_*\n\
10036  constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
10037  PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
10038  style is not returned.\n\
10039 \n\
10040  p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10041  font weight. The available values are given by the PL_FCI_*\n\
10042  constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
10043  PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
10044  returned.\n\
10045 ";
10046 static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
10047 Get z axis parameters\n\
10048 \n\
10049 DESCRIPTION:\n\
10050 \n\
10051  Identical to plgxax, except that arguments are flags for z axis. See\n\
10052  the description of plgxax for more detail.\n\
10053 \n\
10054  Redacted form: plgzax(p_digmax, p_digits)\n\
10055 \n\
10056  This function is used in example 31.\n\
10057 \n\
10058 \n\
10059 \n\
10060 SYNOPSIS:\n\
10061 \n\
10062 plgzax(p_digmax, p_digits)\n\
10063 \n\
10064 ARGUMENTS:\n\
10065 \n\
10066  p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
10067  number of digits for the z axis. If nonzero, the printed label\n\
10068  has been switched to a floating-point representation when the\n\
10069  number of digits exceeds this value.\n\
10070 \n\
10071  p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
10072  number of digits for the numeric labels (z axis) from the last\n\
10073  plot.\n\
10074 ";
10075 static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
10076 Write text inside the viewport of a 3D plot\n\
10077 \n\
10078 DESCRIPTION:\n\
10079 \n\
10080  Writes text at a specified position and inclination and with a\n\
10081  specified shear within the viewport. Text is clipped at the viewport\n\
10082  boundaries. The reference point of a string lies along a line passing\n\
10083  through the string at half the height of a capital letter. The\n\
10084  position of the reference point along this line is determined by just,\n\
10085  and the reference point is placed at world coordinates (\n\
10086  wx,\n\
10087  wy,\n\
10088  wz) within the viewport. The inclination and shear of the string is\n\
10089  specified in terms of differences of world coordinates making it easy\n\
10090  to write text parallel to a line in a graph.\n\
10091 \n\
10092  Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
10093 \n\
10094  This function is used in example 28.\n\
10095 \n\
10096 \n\
10097 \n\
10098 SYNOPSIS:\n\
10099 \n\
10100 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
10101 \n\
10102 ARGUMENTS:\n\
10103 \n\
10104  wx (PLFLT, input) : x world coordinate of reference point of\n\
10105  string.\n\
10106 \n\
10107  wy (PLFLT, input) : y world coordinate of reference point of\n\
10108  string.\n\
10109 \n\
10110  wz (PLFLT, input) : z world coordinate of reference point of\n\
10111  string.\n\
10112 \n\
10113  dx (PLFLT, input) : Together with dy and\n\
10114  dz , this specifies the inclination of the string. The baseline of\n\
10115  the string is parallel to a line joining (\n\
10116  x,\n\
10117  y,\n\
10118  z) to (\n\
10119  x+\n\
10120  dx,\n\
10121  y+\n\
10122  dy,\n\
10123  z+\n\
10124  dz) .\n\
10125 \n\
10126  dy (PLFLT, input) : Together with dx and\n\
10127  dz, this specifies the inclination of the string.\n\
10128 \n\
10129  dz (PLFLT, input) : Together with dx and\n\
10130  dy, this specifies the inclination of the string.\n\
10131 \n\
10132  sx (PLFLT, input) : Together with sy and\n\
10133  sz , this specifies the shear of the string. The string is sheared so\n\
10134  that the characters are vertically parallel to a line joining (\n\
10135  x,\n\
10136  y,\n\
10137  z) to (\n\
10138  x+\n\
10139  sx,\n\
10140  y+\n\
10141  sy,\n\
10142  z+\n\
10143  sz) . If sx =\n\
10144  sy =\n\
10145  sz = 0.) then the text is not sheared.\n\
10146 \n\
10147  sy (PLFLT, input) : Together with sx and\n\
10148  sz, this specifies shear of the string.\n\
10149 \n\
10150  sz (PLFLT, input) : Together with sx and\n\
10151  sy, this specifies shear of the string.\n\
10152 \n\
10153  just (PLFLT, input) : Specifies the position of the string relative\n\
10154  to its reference point. If just=0. , the reference point is at\n\
10155  the left and if just=1. , it is at the right of the string. Other\n\
10156  values of just give intermediate justifications.\n\
10157 \n\
10158  text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
10159  written out.\n\
10160 ";
10161 static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
10162 Draw a box with axes, etc. with arbitrary origin\n\
10163 \n\
10164 DESCRIPTION:\n\
10165 \n\
10166  Draws a box around the currently defined viewport with arbitrary\n\
10167  world-coordinate origin specified by x0 and y0 and labels it with\n\
10168  world coordinate values appropriate to the window. Thus plaxes should\n\
10169  only be called after defining both viewport and window. The ascii\n\
10170  character strings xopt and yopt specify how the box should be drawn as\n\
10171  described below. If ticks and/or subticks are to be drawn for a\n\
10172  particular axis, the tick intervals and number of subintervals may be\n\
10173  specified explicitly, or they may be defaulted by setting the\n\
10174  appropriate arguments to zero.\n\
10175 \n\
10176  Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
10177  ytick, nysub)\n\
10178 \n\
10179 \n\
10180  This function is not used in any examples.\n\
10181 \n\
10182 \n\
10183 \n\
10184 SYNOPSIS:\n\
10185 \n\
10186 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
10187 \n\
10188 ARGUMENTS:\n\
10189 \n\
10190  x0 (PLFLT, input) : World X coordinate of origin.\n\
10191 \n\
10192  y0 (PLFLT, input) : World Y coordinate of origin.\n\
10193 \n\
10194  xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10195  options for the x axis. The string can include any combination of\n\
10196  the following letters (upper or lower case) in any order: a: Draws\n\
10197  axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
10198  (x=0).\n\
10199  b: Draws bottom (X) or left (Y) edge of frame.\n\
10200  c: Draws top (X) or right (Y) edge of frame.\n\
10201  d: Plot labels as date / time. Values are assumed to be\n\
10202  seconds since the epoch (as used by gmtime).\n\
10203  f: Always use fixed point numeric labels.\n\
10204  g: Draws a grid at the major tick interval.\n\
10205  h: Draws a grid at the minor tick interval.\n\
10206  i: Inverts tick marks, so they are drawn outwards, rather than\n\
10207  inwards.\n\
10208  l: Labels axis logarithmically. This only affects the labels,\n\
10209  not the data, and so it is necessary to compute the logarithms\n\
10210  of data points before passing them to any of the drawing\n\
10211  routines.\n\
10212  m: Writes numeric labels at major tick intervals in the\n\
10213  unconventional location (above box for X, right of box for Y).\n\
10214  n: Writes numeric labels at major tick intervals in the\n\
10215  conventional location (below box for X, left of box for Y).\n\
10216  o: Use custom labelling function to generate axis label text.\n\
10217  The custom labelling function can be defined with the\n\
10218  plslabelfunc command.\n\
10219  s: Enables subticks between major ticks, only valid if t is\n\
10220  also specified.\n\
10221  t: Draws major ticks.\n\
10222  u: Exactly like \"b\" except don\'t draw edge line.\n\
10223  w: Exactly like \"c\" except don\'t draw edge line.\n\
10224  x: Exactly like \"t\" (including the side effect of the\n\
10225  numerical labels for the major ticks) except exclude drawing\n\
10226  the major and minor tick marks.\n\
10227 \n\
10228 \n\
10229  xtick (PLFLT, input) : World coordinate interval between major\n\
10230  ticks on the x axis. If it is set to zero, PLplot automatically\n\
10231  generates a suitable tick interval.\n\
10232 \n\
10233  nxsub (PLINT, input) : Number of subintervals between major x axis\n\
10234  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10235  generates a suitable minor tick interval.\n\
10236 \n\
10237  yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10238  options for the y axis. The string can include any combination of\n\
10239  the letters defined above for xopt, and in addition may contain:\n\
10240  v: Write numeric labels for the y axis parallel to the base of the\n\
10241  graph, rather than parallel to the axis.\n\
10242 \n\
10243 \n\
10244  ytick (PLFLT, input) : World coordinate interval between major\n\
10245  ticks on the y axis. If it is set to zero, PLplot automatically\n\
10246  generates a suitable tick interval.\n\
10247 \n\
10248  nysub (PLINT, input) : Number of subintervals between major y axis\n\
10249  ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10250  generates a suitable minor tick interval.\n\
10251 ";
10252 static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
10253 Returns the background color (cmap0[0]) by 8-bit RGB value\n\
10254 \n\
10255 DESCRIPTION:\n\
10256 \n\
10257  Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
10258 \n\
10259  Redacted form: plgcolbg(r, g, b)\n\
10260 \n\
10261  This function is used in example 31.\n\
10262 \n\
10263 \n\
10264 \n\
10265 SYNOPSIS:\n\
10266 \n\
10267 plgcolbg(r, g, b)\n\
10268 \n\
10269 ARGUMENTS:\n\
10270 \n\
10271  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10272  in the range from 0 to 255.\n\
10273 \n\
10274  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10275  in the range from 0 to 255.\n\
10276 \n\
10277  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10278  in the range from 0 to 255.\n\
10279 ";
10280 static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
10281 Plot a glyph at the specified 3D points\n\
10282 \n\
10283 DESCRIPTION:\n\
10284 \n\
10285  Plot a glyph at the specified 3D points. (This function is largely\n\
10286  superseded by plstring3 which gives access to many[!] more glyphs.)\n\
10287  Set up the call to this function similar to what is done for plline3.\n\
10288  code=-1 means try to just draw a point. Right now it\'s just a move\n\
10289  and a draw at the same place. Not ideal, since a sufficiently\n\
10290  intelligent output device may optimize it away, or there may be faster\n\
10291  ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
10292  over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
10293  and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
10294  useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
10295  code <= 127 the corresponding printable ASCII character is plotted.\n\
10296 \n\
10297  Redacted form: plpoin3(x, y, z, code)\n\
10298 \n\
10299  This function is not used in any example.\n\
10300 \n\
10301 \n\
10302 \n\
10303 SYNOPSIS:\n\
10304 \n\
10305 plpoin3(n, x, y, z, code)\n\
10306 \n\
10307 ARGUMENTS:\n\
10308 \n\
10309  n (PLINT, input) : Number of points in the x and y vectors.\n\
10310 \n\
10311  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10312  points.\n\
10313 \n\
10314  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10315  points.\n\
10316 \n\
10317  z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10318  points.\n\
10319 \n\
10320  code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10321  with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10322  each of the n points.\n\
10323 ";
10324 static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10325 Draw a polygon in 3 space\n\
10326 \n\
10327 DESCRIPTION:\n\
10328 \n\
10329  Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10330  like plline3, but differs from that function in that plpoly3 attempts\n\
10331  to determine if the polygon is viewable depending on the order of the\n\
10332  points within the vector and the value of ifcc. If the back of\n\
10333  polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10334  you want, then use plline3 instead.\n\
10335 \n\
10336  The points are assumed to be in a plane, and the directionality of the\n\
10337  plane is determined from the first three points. Additional points do\n\
10338  not have to lie on the plane defined by the first three, but if they\n\
10339  do not, then the determination of visibility obviously can\'t be 100%\n\
10340  accurate... So if you\'re 3 space polygons are too far from planar,\n\
10341  consider breaking them into smaller polygons. 3 points define a plane\n\
10342  :-).\n\
10343 \n\
10344  Bugs: If one of the first two segments is of zero length, or if they\n\
10345  are co-linear, the calculation of visibility has a 50/50 chance of\n\
10346  being correct. Avoid such situations :-). See x18c.c for an example\n\
10347  of this problem. (Search for 20.1).\n\
10348 \n\
10349  Redacted form: plpoly3(x, y, z, code)\n\
10350 \n\
10351  This function is used in example 18.\n\
10352 \n\
10353 \n\
10354 \n\
10355 SYNOPSIS:\n\
10356 \n\
10357 plpoly3(n, x, y, z, draw, ifcc)\n\
10358 \n\
10359 ARGUMENTS:\n\
10360 \n\
10361  n (PLINT, input) : Number of points defining line.\n\
10362 \n\
10363  x (PLFLT_VECTOR, input) : A vector containing\n\
10364  n x coordinates of points.\n\
10365 \n\
10366  y (PLFLT_VECTOR, input) : A vector containing\n\
10367  n y coordinates of points.\n\
10368 \n\
10369  z (PLFLT_VECTOR, input) : A vector containing\n\
10370  n z coordinates of points.\n\
10371 \n\
10372  draw (PLBOOL_VECTOR, input) : A vector containing\n\
10373  n-1 Boolean values which control drawing the segments of the polygon.\n\
10374  If draw[i] is true, then the polygon segment from index [i] to\n\
10375  [i+1] is drawn, otherwise, not.\n\
10376 \n\
10377  ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10378  polygon is determined by assuming the points are laid out in a\n\
10379  counter-clockwise order. Otherwise, the directionality of the\n\
10380  polygon is determined by assuming the points are laid out in a\n\
10381  clockwise order.\n\
10382 ";
10383 static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
10384 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10385 \n\
10386 DESCRIPTION:\n\
10387 \n\
10388  Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10389  PLFLT alpha transparency value (see the PLplot documentation).\n\
10390 \n\
10391  This function is used in example 31.\n\
10392 \n\
10393 \n\
10394 \n\
10395 SYNOPSIS:\n\
10396 \n\
10397 plscolbga(r, g, b, alpha)\n\
10398 \n\
10399 ARGUMENTS:\n\
10400 \n\
10401  r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10402  degree of red in the color.\n\
10403 \n\
10404  g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10405  degree of green in the color.\n\
10406 \n\
10407  b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10408  degree of blue in the color.\n\
10409 \n\
10410  alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10411  (0.0-1.0).\n\
10412 ";
10413 static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
10414 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10415 \n\
10416 DESCRIPTION:\n\
10417 \n\
10418  Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10419  alpha transparency value.\n\
10420 \n\
10421  This function is used in example 31.\n\
10422 \n\
10423 \n\
10424 \n\
10425 SYNOPSIS:\n\
10426 \n\
10427 plgcolbga(r, g, b, alpha)\n\
10428 \n\
10429 ARGUMENTS:\n\
10430 \n\
10431  r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10432  in the range from 0 to 255.\n\
10433 \n\
10434  g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10435  in the range from 0 to 255.\n\
10436 \n\
10437  b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10438  in the range from 0 to 255.\n\
10439 \n\
10440  alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10441  transparency in the range (0.0-1.0).\n\
10442 ";
10443 static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
10444 Draw error bars in x direction\n\
10445 \n\
10446 DESCRIPTION:\n\
10447 \n\
10448  Draws a set of n error bars in x direction, the i\'th error bar\n\
10449  extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10450  of the error bars are of length equal to the minor tick length\n\
10451  (settable using plsmin).\n\
10452 \n\
10453  Redacted form: General: plerrx(xmin, ymax, y)\n\
10454 \n\
10455 \n\
10456  This function is used in example 29.\n\
10457 \n\
10458 \n\
10459 \n\
10460 SYNOPSIS:\n\
10461 \n\
10462 plerrx(n, xmin, xmax, y)\n\
10463 \n\
10464 ARGUMENTS:\n\
10465 \n\
10466  n (PLINT, input) : Number of error bars to draw.\n\
10467 \n\
10468  xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10469  of the left-hand endpoints of the error bars.\n\
10470 \n\
10471  xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10472  of the right-hand endpoints of the error bars.\n\
10473 \n\
10474  y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10475  the error bars.\n\
10476 ";
10477 static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
10478 Eject current page\n\
10479 \n\
10480 DESCRIPTION:\n\
10481 \n\
10482  Clears the graphics screen of an interactive device, or ejects a page\n\
10483  on a plotter. See plbop for more information.\n\
10484 \n\
10485  Redacted form: pleop()\n\
10486 \n\
10487  This function is used in example 2,14.\n\
10488 \n\
10489 \n\
10490 \n\
10491 SYNOPSIS:\n\
10492 \n\
10493 pleop()\n\
10494 ";
10495 static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
10496 Convert HLS color to RGB\n\
10497 \n\
10498 DESCRIPTION:\n\
10499 \n\
10500  Convert HLS color coordinates to RGB.\n\
10501 \n\
10502  Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10503 \n\
10504 \n\
10505  This function is used in example 2.\n\
10506 \n\
10507 \n\
10508 \n\
10509 SYNOPSIS:\n\
10510 \n\
10511 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10512 \n\
10513 ARGUMENTS:\n\
10514 \n\
10515  h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10516  cylinder.\n\
10517 \n\
10518  l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10519  the axis of the color cylinder.\n\
10520 \n\
10521  s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10522  the radius of the color cylinder.\n\
10523 \n\
10524  p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10525  (0.0-1.0) of the color.\n\
10526 \n\
10527  p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10528  intensity (0.0-1.0) of the color.\n\
10529 \n\
10530  p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10531  intensity (0.0-1.0) of the color.\n\
10532 ";
10533 static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
10534 Plot all or a subset of Shapefile data, filling the polygons\n\
10535 \n\
10536 DESCRIPTION:\n\
10537 \n\
10538  As per plmapline, however the items are filled in the same way as\n\
10539  plfill.\n\
10540 \n\
10541  Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10542  plotentries)\n\
10543 \n\
10544  This function is used in example 19.\n\
10545 \n\
10546 \n\
10547 \n\
10548 SYNOPSIS:\n\
10549 \n\
10550 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10551 \n\
10552 ARGUMENTS:\n\
10553 \n\
10554  mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10555  transform the coordinates given in the shapefile into a plot\n\
10556  coordinate system. By using this transform, we can change from a\n\
10557  longitude, latitude coordinate to a polar stereographic project,\n\
10558  for example. Initially, x[0]..[n-1] are the longitudes and\n\
10559  y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10560  mapform(), x[] and y[] should be replaced by the corresponding\n\
10561  plot coordinates. If no transform is desired, mapform can be\n\
10562  replaced by NULL.\n\
10563 \n\
10564  name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10565  the file name of a set of Shapefile files without the file\n\
10566  extension.\n\
10567 \n\
10568  minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10569  be in the same units as used by the Shapefile. You could use a\n\
10570  very large negative number to plot everything, but you can improve\n\
10571  performance by limiting the area drawn. The units must match those\n\
10572  of the Shapefile projection, which may be for example longitude or\n\
10573  distance. The value of minx must be less than the value of maxx.\n\
10574 \n\
10575  maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10576  use a very large number to plot everything, but you can improve\n\
10577  performance by limiting the area drawn.\n\
10578 \n\
10579  miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10580  be in the same units as used by the Shapefile. You could use a\n\
10581  very large negative number to plot everything, but you can improve\n\
10582  performance by limiting the area drawn. The units must match those\n\
10583  of the Shapefile projection, which may be for example latitude or\n\
10584  distance. The value of miny must be less than the value of maxy.\n\
10585 \n\
10586  maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10587  use a very large number to plot everything, but you can improve\n\
10588  performance by limiting the area drawn.\n\
10589 \n\
10590  plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10591  zero-based indices of the Shapefile elements which will be drawn.\n\
10592  Setting\n\
10593  plotentries to NULL will plot all elements of the Shapefile.\n\
10594 \n\
10595  nplotentries (PLINT, input) : The number of items in\n\
10596  plotentries. Ignored if\n\
10597  plotentries is NULL.\n\
10598 ";
10599 static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
10600 Draw error bars in the y direction\n\
10601 \n\
10602 DESCRIPTION:\n\
10603 \n\
10604  Draws a set of n error bars in the y direction, the i\'th error bar\n\
10605  extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10606  of the error bars are of length equal to the minor tick length\n\
10607  (settable using plsmin).\n\
10608 \n\
10609  Redacted form: General: plerry(x, ymin, ymax)\n\
10610 \n\
10611 \n\
10612  This function is used in example 29.\n\
10613 \n\
10614 \n\
10615 \n\
10616 SYNOPSIS:\n\
10617 \n\
10618 plerry(n, x, ymin, ymax)\n\
10619 \n\
10620 ARGUMENTS:\n\
10621 \n\
10622  n (PLINT, input) : Number of error bars to draw.\n\
10623 \n\
10624  x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10625  the error bars.\n\
10626 \n\
10627  ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10628  of the lower endpoints of the error bars.\n\
10629 \n\
10630  ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10631  of the upper endpoints of the error bars.\n\
10632 ";
10633 static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
10634 Set FCI (font characterization integer)\n\
10635 \n\
10636 DESCRIPTION:\n\
10637 \n\
10638  Sets font characteristics to be used at the start of the next string\n\
10639  using the FCI approach. See the PLplot documentation for more\n\
10640  information. Note, plsfont (which calls plsfci internally) provides a\n\
10641  more user-friendly API for setting the font characterisitics.\n\
10642 \n\
10643  Redacted form: General: plsfci(fci)\n\
10644 \n\
10645 \n\
10646  This function is used in example 23.\n\
10647 \n\
10648 \n\
10649 \n\
10650 SYNOPSIS:\n\
10651 \n\
10652 plsfci(fci)\n\
10653 \n\
10654 ARGUMENTS:\n\
10655 \n\
10656  fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10657  of FCI.\n\
10658 ";
10659 static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
10660 Select area fill pattern\n\
10661 \n\
10662 DESCRIPTION:\n\
10663 \n\
10664  If\n\
10665  patt is zero or less use either a hardware solid fill if the drivers\n\
10666  have that capability (virtually all do) or fall back to a software\n\
10667  emulation of a solid fill using the eighth area line fill pattern. If\n\
10668  0 <\n\
10669  patt <= 8, then select one of eight predefined area line fill patterns\n\
10670  to use (see plpat if you desire other patterns).\n\
10671 \n\
10672  Redacted form: plpsty(patt)\n\
10673 \n\
10674  This function is used in examples 12, 13, 15, 16, and 25.\n\
10675 \n\
10676 \n\
10677 \n\
10678 SYNOPSIS:\n\
10679 \n\
10680 plpsty(patt)\n\
10681 \n\
10682 ARGUMENTS:\n\
10683 \n\
10684  patt (PLINT, input) : The desired pattern index. If\n\
10685  patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10686  above) used. For\n\
10687  patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10688  line fill capability itself (most deliberately do not so that line\n\
10689  fill patterns look identical for those drivers), the patterns\n\
10690  consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10691  45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10692  lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10693  (8) lines at both 45 degrees and -45 degrees.\n\
10694 ";
10695 static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
10696 Set symbol size\n\
10697 \n\
10698 DESCRIPTION:\n\
10699 \n\
10700  This sets up the size of all subsequent symbols drawn by plpoin and\n\
10701  plsym. The actual height of a symbol is the product of the default\n\
10702  symbol size and a scaling factor as for the character height.\n\
10703 \n\
10704  Redacted form: plssym(def, scale)\n\
10705 \n\
10706  This function is used in example 29.\n\
10707 \n\
10708 \n\
10709 \n\
10710 SYNOPSIS:\n\
10711 \n\
10712 plssym(def, scale)\n\
10713 \n\
10714 ARGUMENTS:\n\
10715 \n\
10716  def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10717  should be set to zero if the default height is to remain\n\
10718  unchanged.\n\
10719 \n\
10720  scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10721  actual symbol height.\n\
10722 ";
10723 static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
10724 Initialization\n\
10725 \n\
10726 DESCRIPTION:\n\
10727 \n\
10728  Alternative to plstar for initializing the plotting package. The\n\
10729  device name keyword for the desired output device must be supplied as\n\
10730  an argument. These keywords are the same as those printed out by\n\
10731  plstar. If the requested device is not available, or if the input\n\
10732  string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10733  is used. This routine also divides the output device page into nx by\n\
10734  ny subpages, each of which may be used independently. The subroutine\n\
10735  pladv is used to advance from one subpage to the next.\n\
10736 \n\
10737  Redacted form: General: plstart(devname, nx, ny)\n\
10738 \n\
10739 \n\
10740  This function is not used in any examples.\n\
10741 \n\
10742 \n\
10743 \n\
10744 SYNOPSIS:\n\
10745 \n\
10746 plstart(devname, nx, ny)\n\
10747 \n\
10748 ARGUMENTS:\n\
10749 \n\
10750  devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10751  containing the device name keyword of the required output device.\n\
10752  If\n\
10753  devname is NULL or if the first character of the string is a ``?\'\',\n\
10754  the normal (prompted) start up is used.\n\
10755 \n\
10756  nx (PLINT, input) : Number of subpages to divide output page in the\n\
10757  x direction.\n\
10758 \n\
10759  ny (PLINT, input) : Number of subpages to divide output page in the\n\
10760  y direction.\n\
10761 ";
10762 
10763 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10764  PLINT arg1 ;
10765  PLINT *arg2 = (PLINT *) 0 ;
10766  char **arg3 = (char **) 0 ;
10767  Matrix temp1 ;
10768  octave_value_list _out;
10769  octave_value_list *_outp=&_out;
10770  octave_value _outv;
10771 
10772  if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10773  SWIG_fail;
10774  }
10775  {
10776  if ( _n_dims( args(0) ) > 1 )
10777  {
10778  error( "argument must be a scalar or vector" ); SWIG_fail;
10779  }
10780  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10781  arg2 = new PLINT[Alen];
10782  temp1 = args(0).matrix_value();
10783  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10784  }
10785  {
10786  charMatrix temp_matrix;
10787  Cell temp_cell;
10788  char *tmp_cstring;
10789  std::string str;
10790  size_t max_length = 0, non_blank_length;
10791  int i, ifcell;
10792  if ( _n_dims( args(1) ) > 2 )
10793  {
10794  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10795  }
10796 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10797  if ( !args(1).isempty() )
10798 #else
10799  if ( !args(1).is_empty() )
10800 #endif
10801  {
10802  if ( _dim( args(1), 0 ) != Alen )
10803  {
10804  error( "first dimension must be same length as previous vector" ); SWIG_fail;
10805  }
10806  arg3 = new char*[Alen];
10807 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10808  ifcell = args(1).iscell();
10809 #else
10810  ifcell = args(1).is_cell();
10811 #endif
10812  if ( ifcell )
10813  {
10814  temp_cell = args(1).cell_value();
10815  }
10816  else
10817  {
10818  temp_matrix = args(1).char_matrix_value();
10819  // Allow one extra space for null termination.
10820  max_length = _dim( args(1), 1 ) + 1;
10821  }
10822 
10823  for ( i = 0; i < Alen; i++ )
10824  {
10825  // Must copy string to "permanent" location because the string
10826  // location corresponding to tmp_cstring gets
10827  // overwritten for each iteration of loop.
10828  if ( ifcell )
10829  {
10830  if ( temp_cell.elem( i ).is_string() )
10831  {
10832  str = temp_cell.elem( i ).string_value();
10833  // leave room for null termination.
10834  max_length = str.size() + 1;
10835  tmp_cstring = (char *) str.c_str();
10836  }
10837  else
10838  {
10839  // Use null string if user attempts to pass a cell array
10840  // with a non-string element (likely an empty element
10841  // since that should be allowed by the PLplot interface
10842  // if that element is going to be unused).
10843  // leave room for null termination.
10844  max_length = 1;
10845  tmp_cstring = (char *) "";
10846  }
10847  }
10848  else
10849  {
10850  str = temp_matrix.row_as_string( i );
10851  tmp_cstring = (char *) str.c_str();
10852  }
10853  arg3[i] = new char[max_length];
10854  strncpy( arg3[i], tmp_cstring, max_length - 1 );
10855  arg3[i][max_length - 1] = '\0';
10856  // All the trailing blank crapola should not be needed for
10857  // string cell arrays.
10858  if ( !ifcell )
10859  {
10860  // remove trailing-blank padding that is used by the
10861  // charMatrix class to insure all strings in a given
10862  // charMatrix instance have the same length.
10863  // This transformation also removes legitimate trailing
10864  // blanks but there is nothing we can do about that
10865  // for the charMatrix class.
10866 
10867  // Look for trailing nulls first (just in case, although that
10868  // shouldn't happen if charMatrix implemented as documented)
10869  // before looking for trailing blanks.
10870  non_blank_length = max_length - 2;
10871  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
10872  {
10873  non_blank_length--;
10874  }
10875  while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
10876  {
10877  non_blank_length--;
10878  }
10879  arg3[i][non_blank_length + 1] = '\0';
10880  }
10881  }
10882  }
10883  else
10884  {
10885  arg3 = NULL;
10886  }
10887  }
10888  testppchar(arg1,(int const *)arg2,(char const **)arg3);
10889  _outv = octave_value();
10890  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10891  {
10892  delete [] arg2;
10893  }
10894  {
10895  int i;
10896  if ( arg3 != NULL )
10897  {
10898  for ( i = 0; i < Alen; i++ )
10899  {
10900  delete[] arg3[i];
10901  }
10902  delete[] arg3;
10903  }
10904  }
10905  return _out;
10906 fail:
10907  {
10908  delete [] arg2;
10909  }
10910  {
10911  int i;
10912  if ( arg3 != NULL )
10913  {
10914  for ( i = 0; i < Alen; i++ )
10915  {
10916  delete[] arg3[i];
10917  }
10918  delete[] arg3;
10919  }
10920  }
10921  return octave_value_list();
10922 }
10923 
10924 
10926  int *arg1 = (int *) 0 ;
10927  int *arg2 = (int *) 0 ;
10928  int *arg3 = (int *) 0 ;
10929  char *arg4 = (char *) 0 ;
10930  int *arg5 = (int *) 0 ;
10931  int *arg6 = (int *) 0 ;
10932  PLFLT *arg7 = (PLFLT *) 0 ;
10933  PLFLT *arg8 = (PLFLT *) 0 ;
10934  PLFLT *arg9 = (PLFLT *) 0 ;
10935  PLFLT *arg10 = (PLFLT *) 0 ;
10936  int *arg11 = (int *) 0 ;
10937  int temp1 ;
10938  int res1 = SWIG_TMPOBJ ;
10939  int temp2 ;
10940  int res2 = SWIG_TMPOBJ ;
10941  int temp3 ;
10942  int res3 = SWIG_TMPOBJ ;
10943  char local_string4[80] ;
10944  int temp5 ;
10945  int res5 = SWIG_TMPOBJ ;
10946  int temp6 ;
10947  int res6 = SWIG_TMPOBJ ;
10948  PLFLT temp7 ;
10949  int res7 = SWIG_TMPOBJ ;
10950  PLFLT temp8 ;
10951  int res8 = SWIG_TMPOBJ ;
10952  PLFLT temp9 ;
10953  int res9 = SWIG_TMPOBJ ;
10954  PLFLT temp10 ;
10955  int res10 = SWIG_TMPOBJ ;
10956  int temp11 ;
10957  int res11 = SWIG_TMPOBJ ;
10958  size_t local_string_length4 ;
10959  charMatrix local_charMatrix4 ;
10960  octave_value_list retval4 ;
10961  octave_value_list _out;
10962  octave_value_list *_outp=&_out;
10963  octave_value _outv;
10964  int result;
10965 
10966  arg1 = &temp1;
10967  arg2 = &temp2;
10968  arg3 = &temp3;
10969  {
10970  arg4 = local_string4;
10971  }
10972  arg5 = &temp5;
10973  arg6 = &temp6;
10974  arg7 = &temp7;
10975  arg8 = &temp8;
10976  arg9 = &temp9;
10977  arg10 = &temp10;
10978  arg11 = &temp11;
10979  if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
10980  SWIG_fail;
10981  }
10982  result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
10983  _outv = SWIG_From_int(static_cast< int >(result));
10984  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10985  if (SWIG_IsTmpObj(res1)) {
10986  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
10987  } else {
10988  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10989  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
10990  }
10991  if (SWIG_IsTmpObj(res2)) {
10992  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
10993  } else {
10994  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10995  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
10996  }
10997  if (SWIG_IsTmpObj(res3)) {
10998  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
10999  } else {
11000  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11001  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11002  }
11003  {
11004  local_string_length4 = strlen( local_string4 );
11005  local_charMatrix4 = charMatrix( 1, local_string_length4 );
11006  local_charMatrix4.insert( local_string4, 0, 0 );
11007  retval4( 0 ) = octave_value( local_charMatrix4 );
11008  _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
11009  }
11010  if (SWIG_IsTmpObj(res5)) {
11011  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11012  } else {
11013  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11014  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11015  }
11016  if (SWIG_IsTmpObj(res6)) {
11017  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11018  } else {
11019  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11020  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11021  }
11022  if (SWIG_IsTmpObj(res7)) {
11023  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11024  } else {
11025  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11026  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11027  }
11028  if (SWIG_IsTmpObj(res8)) {
11029  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11030  } else {
11031  int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11032  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11033  }
11034  if (SWIG_IsTmpObj(res9)) {
11035  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11036  } else {
11037  int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11038  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11039  }
11040  if (SWIG_IsTmpObj(res10)) {
11041  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11042  } else {
11043  int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11044  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11045  }
11046  if (SWIG_IsTmpObj(res11)) {
11047  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11048  } else {
11049  int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11050  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11051  }
11052  return _out;
11053 fail:
11054  return octave_value_list();
11055 }
11056 
11057 
11058 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11059  PLFLT *arg1 = (PLFLT *) 0 ;
11060  PLFLT *arg2 = (PLFLT *) 0 ;
11061  PLFLT arg3 ;
11062  PLFLT arg4 ;
11063  PLFLT temp1 ;
11064  int res1 = SWIG_TMPOBJ ;
11065  PLFLT temp2 ;
11066  int res2 = SWIG_TMPOBJ ;
11067  double val3 ;
11068  int ecode3 = 0 ;
11069  double val4 ;
11070  int ecode4 = 0 ;
11071  octave_value_list _out;
11072  octave_value_list *_outp=&_out;
11073  octave_value _outv;
11074  int result;
11075 
11076  arg1 = &temp1;
11077  arg2 = &temp2;
11078  if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11079  SWIG_fail;
11080  }
11081  ecode3 = SWIG_AsVal_double(args(0), &val3);
11082  if (!SWIG_IsOK(ecode3)) {
11083  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11084  }
11085  arg3 = static_cast< PLFLT >(val3);
11086  ecode4 = SWIG_AsVal_double(args(1), &val4);
11087  if (!SWIG_IsOK(ecode4)) {
11088  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11089  }
11090  arg4 = static_cast< PLFLT >(val4);
11091  result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11092  _outv = SWIG_From_int(static_cast< int >(result));
11093  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11094  if (SWIG_IsTmpObj(res1)) {
11095  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11096  } else {
11097  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11098  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11099  }
11100  if (SWIG_IsTmpObj(res2)) {
11101  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11102  } else {
11103  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11104  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11105  }
11106  return _out;
11107 fail:
11108  return octave_value_list();
11109 }
11110 
11111 
11113  PLINT *arg1 = (PLINT *) 0 ;
11114  char *arg2 = (char *) 0 ;
11115  char *arg3 = (char *) 0 ;
11116  PLFLT arg4 ;
11117  PLFLT arg5 ;
11118  PLFLT arg6 ;
11119  PLFLT arg7 ;
11120  PLFLT arg8 ;
11121  PLFLT arg9 ;
11122  PLFLT arg10 ;
11123  PLBOOL arg11 ;
11124  PLBOOL arg12 ;
11125  PLINT arg13 ;
11126  PLINT arg14 ;
11127  PLINT *arg15 = (PLINT *) 0 ;
11128  PLINT *arg16 = (PLINT *) 0 ;
11129  char *arg17 = (char *) 0 ;
11130  char *arg18 = (char *) 0 ;
11131  char *arg19 = (char *) 0 ;
11132  char *arg20 = (char *) 0 ;
11133  char *arg21 = (char *) 0 ;
11134  char *arg22 = (char *) 0 ;
11135  char *arg23 = (char *) 0 ;
11136  PLINT temp1 ;
11137  int res1 = SWIG_TMPOBJ ;
11138  int res2 ;
11139  char *buf2 = 0 ;
11140  int alloc2 = 0 ;
11141  int res3 ;
11142  char *buf3 = 0 ;
11143  int alloc3 = 0 ;
11144  double val4 ;
11145  int ecode4 = 0 ;
11146  double val5 ;
11147  int ecode5 = 0 ;
11148  double val6 ;
11149  int ecode6 = 0 ;
11150  double val7 ;
11151  int ecode7 = 0 ;
11152  double val8 ;
11153  int ecode8 = 0 ;
11154  double val9 ;
11155  int ecode9 = 0 ;
11156  double val10 ;
11157  int ecode10 = 0 ;
11158  int val11 ;
11159  int ecode11 = 0 ;
11160  int val12 ;
11161  int ecode12 = 0 ;
11162  int val13 ;
11163  int ecode13 = 0 ;
11164  int val14 ;
11165  int ecode14 = 0 ;
11166  Matrix temp15 ;
11167  Matrix temp16 ;
11168  int res17 ;
11169  char *buf17 = 0 ;
11170  int alloc17 = 0 ;
11171  int res18 ;
11172  char *buf18 = 0 ;
11173  int alloc18 = 0 ;
11174  int res19 ;
11175  char *buf19 = 0 ;
11176  int alloc19 = 0 ;
11177  int res20 ;
11178  char *buf20 = 0 ;
11179  int alloc20 = 0 ;
11180  int res21 ;
11181  char *buf21 = 0 ;
11182  int alloc21 = 0 ;
11183  int res22 ;
11184  char *buf22 = 0 ;
11185  int alloc22 = 0 ;
11186  int res23 ;
11187  char *buf23 = 0 ;
11188  int alloc23 = 0 ;
11189  octave_value_list _out;
11190  octave_value_list *_outp=&_out;
11191  octave_value _outv;
11192 
11193  arg1 = &temp1;
11194  if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11195  SWIG_fail;
11196  }
11197  res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11198  if (!SWIG_IsOK(res2)) {
11199  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11200  }
11201  arg2 = reinterpret_cast< char * >(buf2);
11202  res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11203  if (!SWIG_IsOK(res3)) {
11204  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11205  }
11206  arg3 = reinterpret_cast< char * >(buf3);
11207  ecode4 = SWIG_AsVal_double(args(2), &val4);
11208  if (!SWIG_IsOK(ecode4)) {
11209  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11210  }
11211  arg4 = static_cast< PLFLT >(val4);
11212  ecode5 = SWIG_AsVal_double(args(3), &val5);
11213  if (!SWIG_IsOK(ecode5)) {
11214  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11215  }
11216  arg5 = static_cast< PLFLT >(val5);
11217  ecode6 = SWIG_AsVal_double(args(4), &val6);
11218  if (!SWIG_IsOK(ecode6)) {
11219  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11220  }
11221  arg6 = static_cast< PLFLT >(val6);
11222  ecode7 = SWIG_AsVal_double(args(5), &val7);
11223  if (!SWIG_IsOK(ecode7)) {
11224  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11225  }
11226  arg7 = static_cast< PLFLT >(val7);
11227  ecode8 = SWIG_AsVal_double(args(6), &val8);
11228  if (!SWIG_IsOK(ecode8)) {
11229  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11230  }
11231  arg8 = static_cast< PLFLT >(val8);
11232  ecode9 = SWIG_AsVal_double(args(7), &val9);
11233  if (!SWIG_IsOK(ecode9)) {
11234  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11235  }
11236  arg9 = static_cast< PLFLT >(val9);
11237  ecode10 = SWIG_AsVal_double(args(8), &val10);
11238  if (!SWIG_IsOK(ecode10)) {
11239  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11240  }
11241  arg10 = static_cast< PLFLT >(val10);
11242  ecode11 = SWIG_AsVal_int(args(9), &val11);
11243  if (!SWIG_IsOK(ecode11)) {
11244  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11245  }
11246  arg11 = static_cast< PLBOOL >(val11);
11247  ecode12 = SWIG_AsVal_int(args(10), &val12);
11248  if (!SWIG_IsOK(ecode12)) {
11249  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11250  }
11251  arg12 = static_cast< PLBOOL >(val12);
11252  ecode13 = SWIG_AsVal_int(args(11), &val13);
11253  if (!SWIG_IsOK(ecode13)) {
11254  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11255  }
11256  arg13 = static_cast< PLINT >(val13);
11257  ecode14 = SWIG_AsVal_int(args(12), &val14);
11258  if (!SWIG_IsOK(ecode14)) {
11259  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11260  }
11261  arg14 = static_cast< PLINT >(val14);
11262  {
11263  if ( _n_dims( args(13) ) > 1 )
11264  {
11265  error( "argument must be a scalar or vector" ); SWIG_fail;
11266  }
11267  Alen = (PLINT) ( _dim( args(13), 0 ) );
11268  temp15 = args(13).matrix_value();
11269  arg15 = new PLINT[Alen];
11270  _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11271  }
11272  {
11273  if ( _n_dims( args(14) ) > 1 )
11274  {
11275  error( "argument must be a scalar or vector" ); SWIG_fail;
11276  }
11277  if ( _dim( args(14), 0 ) != Alen )
11278  {
11279  error( "argument vectors must be same length" ); SWIG_fail;
11280  }
11281  temp16 = args(14).matrix_value();
11282  arg16 = new PLINT[Alen];
11283  _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11284  }
11285  res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11286  if (!SWIG_IsOK(res17)) {
11287  SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11288  }
11289  arg17 = reinterpret_cast< char * >(buf17);
11290  res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11291  if (!SWIG_IsOK(res18)) {
11292  SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11293  }
11294  arg18 = reinterpret_cast< char * >(buf18);
11295  res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11296  if (!SWIG_IsOK(res19)) {
11297  SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11298  }
11299  arg19 = reinterpret_cast< char * >(buf19);
11300  res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11301  if (!SWIG_IsOK(res20)) {
11302  SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11303  }
11304  arg20 = reinterpret_cast< char * >(buf20);
11305  res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11306  if (!SWIG_IsOK(res21)) {
11307  SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11308  }
11309  arg21 = reinterpret_cast< char * >(buf21);
11310  res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11311  if (!SWIG_IsOK(res22)) {
11312  SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11313  }
11314  arg22 = reinterpret_cast< char * >(buf22);
11315  res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11316  if (!SWIG_IsOK(res23)) {
11317  SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11318  }
11319  arg23 = reinterpret_cast< char * >(buf23);
11320  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);
11321  _outv = octave_value();
11322  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11323  if (SWIG_IsTmpObj(res1)) {
11324  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11325  } else {
11326  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11327  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11328  }
11329  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11330  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11331  {
11332  delete [] arg15;
11333  }
11334  {
11335  delete [] arg16;
11336  }
11337  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11338  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11339  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11340  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11341  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11342  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11343  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11344  return _out;
11345 fail:
11346  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11347  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11348  {
11349  delete [] arg15;
11350  }
11351  {
11352  delete [] arg16;
11353  }
11354  if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11355  if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11356  if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11357  if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11358  if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11359  if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11360  if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11361  return octave_value_list();
11362 }
11363 
11364 
11366  PLFLT *arg1 = (PLFLT *) 0 ;
11367  PLINT arg2 ;
11368  PLINT arg3 ;
11369  PLINT arg4 ;
11370  PLINT arg5 ;
11371  PLINT arg6 ;
11372  PLINT arg7 ;
11373  PLFLT *arg8 = (PLFLT *) 0 ;
11374  PLINT arg9 ;
11375  PLFLT *arg10 = (PLFLT *) 0 ;
11376  Matrix temp1 ;
11377  int val4 ;
11378  int ecode4 = 0 ;
11379  int val5 ;
11380  int ecode5 = 0 ;
11381  int val6 ;
11382  int ecode6 = 0 ;
11383  int val7 ;
11384  int ecode7 = 0 ;
11385  Matrix temp8 ;
11386  Matrix temp10 ;
11387  octave_value_list _out;
11388  octave_value_list *_outp=&_out;
11389  octave_value _outv;
11390 
11391  if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11392  SWIG_fail;
11393  }
11394  {
11395  if ( _n_dims( args(0) ) > 2 )
11396  {
11397  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11398  }
11399  temp1 = args(0).matrix_value();
11400  arg1 = &temp1( 0, 0 );
11401  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11402  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11403  }
11404  ecode4 = SWIG_AsVal_int(args(1), &val4);
11405  if (!SWIG_IsOK(ecode4)) {
11406  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11407  }
11408  arg4 = static_cast< PLINT >(val4);
11409  ecode5 = SWIG_AsVal_int(args(2), &val5);
11410  if (!SWIG_IsOK(ecode5)) {
11411  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11412  }
11413  arg5 = static_cast< PLINT >(val5);
11414  ecode6 = SWIG_AsVal_int(args(3), &val6);
11415  if (!SWIG_IsOK(ecode6)) {
11416  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11417  }
11418  arg6 = static_cast< PLINT >(val6);
11419  ecode7 = SWIG_AsVal_int(args(4), &val7);
11420  if (!SWIG_IsOK(ecode7)) {
11421  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11422  }
11423  arg7 = static_cast< PLINT >(val7);
11424  {
11425  if ( _n_dims( args(5) ) > 1 )
11426  {
11427  error( "argument must be a scalar or vector" ); SWIG_fail;
11428  }
11429  temp8 = args(5).matrix_value();
11430  arg8 = &temp8( 0, 0 );
11431  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11432  }
11433  {
11434  if ( _n_dims( args(6) ) > 1 )
11435  {
11436  error( "argument must be a scalar or vector" ); SWIG_fail;
11437  }
11438  if ( _dim( args(6), 0 ) != 6 )
11439  {
11440  error( "argument vectors must have length of 6" ); SWIG_fail;
11441  }
11442  temp10 = args(6).matrix_value();
11443  arg10 = &temp10( 0, 0 );
11444  }
11445  my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11446  _outv = octave_value();
11447  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11448  {
11449 
11450  }
11451  {
11452 
11453  }
11454  {
11455 
11456  }
11457  return _out;
11458 fail:
11459  {
11460 
11461  }
11462  {
11463 
11464  }
11465  {
11466 
11467  }
11468  return octave_value_list();
11469 }
11470 
11471 
11472 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11473  PLFLT *arg1 = (PLFLT *) 0 ;
11474  PLINT arg2 ;
11475  PLINT arg3 ;
11476  PLINT arg4 ;
11477  PLINT arg5 ;
11478  PLINT arg6 ;
11479  PLINT arg7 ;
11480  PLFLT *arg8 = (PLFLT *) 0 ;
11481  PLINT arg9 ;
11482  Matrix temp1 ;
11483  int val4 ;
11484  int ecode4 = 0 ;
11485  int val5 ;
11486  int ecode5 = 0 ;
11487  int val6 ;
11488  int ecode6 = 0 ;
11489  int val7 ;
11490  int ecode7 = 0 ;
11491  Matrix temp8 ;
11492  octave_value_list _out;
11493  octave_value_list *_outp=&_out;
11494  octave_value _outv;
11495 
11496  if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11497  SWIG_fail;
11498  }
11499  {
11500  if ( _n_dims( args(0) ) > 2 )
11501  {
11502  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11503  }
11504  temp1 = args(0).matrix_value();
11505  arg1 = &temp1( 0, 0 );
11506  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11507  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11508  }
11509  ecode4 = SWIG_AsVal_int(args(1), &val4);
11510  if (!SWIG_IsOK(ecode4)) {
11511  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11512  }
11513  arg4 = static_cast< PLINT >(val4);
11514  ecode5 = SWIG_AsVal_int(args(2), &val5);
11515  if (!SWIG_IsOK(ecode5)) {
11516  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11517  }
11518  arg5 = static_cast< PLINT >(val5);
11519  ecode6 = SWIG_AsVal_int(args(3), &val6);
11520  if (!SWIG_IsOK(ecode6)) {
11521  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11522  }
11523  arg6 = static_cast< PLINT >(val6);
11524  ecode7 = SWIG_AsVal_int(args(4), &val7);
11525  if (!SWIG_IsOK(ecode7)) {
11526  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11527  }
11528  arg7 = static_cast< PLINT >(val7);
11529  {
11530  if ( _n_dims( args(5) ) > 1 )
11531  {
11532  error( "argument must be a scalar or vector" ); SWIG_fail;
11533  }
11534  temp8 = args(5).matrix_value();
11535  arg8 = &temp8( 0, 0 );
11536  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11537  }
11538  my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11539  _outv = octave_value();
11540  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11541  {
11542 
11543  }
11544  {
11545 
11546  }
11547  return _out;
11548 fail:
11549  {
11550 
11551  }
11552  {
11553 
11554  }
11555  return octave_value_list();
11556 }
11557 
11558 
11559 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11560  PLFLT *arg1 = (PLFLT *) 0 ;
11561  PLINT arg2 ;
11562  PLINT arg3 ;
11563  PLINT arg4 ;
11564  PLINT arg5 ;
11565  PLINT arg6 ;
11566  PLINT arg7 ;
11567  PLFLT *arg8 = (PLFLT *) 0 ;
11568  PLINT arg9 ;
11569  PLFLT *arg10 = (PLFLT *) 0 ;
11570  PLFLT *arg11 = (PLFLT *) 0 ;
11571  Matrix temp1 ;
11572  int val4 ;
11573  int ecode4 = 0 ;
11574  int val5 ;
11575  int ecode5 = 0 ;
11576  int val6 ;
11577  int ecode6 = 0 ;
11578  int val7 ;
11579  int ecode7 = 0 ;
11580  Matrix temp8 ;
11581  Matrix temp10 ;
11582  Matrix temp11 ;
11583  octave_value_list _out;
11584  octave_value_list *_outp=&_out;
11585  octave_value _outv;
11586 
11587  if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11588  SWIG_fail;
11589  }
11590  {
11591  if ( _n_dims( args(0) ) > 2 )
11592  {
11593  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11594  }
11595  temp1 = args(0).matrix_value();
11596  arg1 = &temp1( 0, 0 );
11597  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11598  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11599  }
11600  ecode4 = SWIG_AsVal_int(args(1), &val4);
11601  if (!SWIG_IsOK(ecode4)) {
11602  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11603  }
11604  arg4 = static_cast< PLINT >(val4);
11605  ecode5 = SWIG_AsVal_int(args(2), &val5);
11606  if (!SWIG_IsOK(ecode5)) {
11607  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11608  }
11609  arg5 = static_cast< PLINT >(val5);
11610  ecode6 = SWIG_AsVal_int(args(3), &val6);
11611  if (!SWIG_IsOK(ecode6)) {
11612  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11613  }
11614  arg6 = static_cast< PLINT >(val6);
11615  ecode7 = SWIG_AsVal_int(args(4), &val7);
11616  if (!SWIG_IsOK(ecode7)) {
11617  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11618  }
11619  arg7 = static_cast< PLINT >(val7);
11620  {
11621  if ( _n_dims( args(5) ) > 1 )
11622  {
11623  error( "argument must be a scalar or vector" ); SWIG_fail;
11624  }
11625  temp8 = args(5).matrix_value();
11626  arg8 = &temp8( 0, 0 );
11627  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11628  }
11629  {
11630  if ( _n_dims( args(6) ) > 1 )
11631  {
11632  error( "argument must be a scalar or vector" ); SWIG_fail;
11633  }
11634  if ( _dim( args(6), 0 ) != Xlen )
11635  {
11636  error( "argument vectors must be same length" ); SWIG_fail;
11637  }
11638  temp10 = args(6).matrix_value();
11639  arg10 = &temp10( 0, 0 );
11640  }
11641  {
11642  if ( _n_dims( args(7) ) > 1 )
11643  {
11644  error( "argument must be a scalar or vector" ); SWIG_fail;
11645  }
11646  if ( _dim( args(7), 0 ) != Ylen )
11647  {
11648  error( "argument vectors must be same length" ); SWIG_fail;
11649  }
11650  temp11 = args(7).matrix_value();
11651  arg11 = &temp11( 0, 0 );
11652  }
11653  my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11654  _outv = octave_value();
11655  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11656  {
11657 
11658  }
11659  {
11660 
11661  }
11662  {
11663 
11664  }
11665  {
11666 
11667  }
11668  return _out;
11669 fail:
11670  {
11671 
11672  }
11673  {
11674 
11675  }
11676  {
11677 
11678  }
11679  {
11680 
11681  }
11682  return octave_value_list();
11683 }
11684 
11685 
11686 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
11687  PLFLT *arg1 = (PLFLT *) 0 ;
11688  PLINT arg2 ;
11689  PLINT arg3 ;
11690  PLINT arg4 ;
11691  PLINT arg5 ;
11692  PLINT arg6 ;
11693  PLINT arg7 ;
11694  PLFLT *arg8 = (PLFLT *) 0 ;
11695  PLINT arg9 ;
11696  PLFLT *arg10 = (PLFLT *) 0 ;
11697  PLFLT *arg11 = (PLFLT *) 0 ;
11698  Matrix temp1 ;
11699  int val4 ;
11700  int ecode4 = 0 ;
11701  int val5 ;
11702  int ecode5 = 0 ;
11703  int val6 ;
11704  int ecode6 = 0 ;
11705  int val7 ;
11706  int ecode7 = 0 ;
11707  Matrix temp8 ;
11708  Matrix temp10 ;
11709  Matrix temp11 ;
11710  octave_value_list _out;
11711  octave_value_list *_outp=&_out;
11712  octave_value _outv;
11713 
11714  if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11715  SWIG_fail;
11716  }
11717  {
11718  if ( _n_dims( args(0) ) > 2 )
11719  {
11720  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11721  }
11722  temp1 = args(0).matrix_value();
11723  arg1 = &temp1( 0, 0 );
11724  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11725  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11726  }
11727  ecode4 = SWIG_AsVal_int(args(1), &val4);
11728  if (!SWIG_IsOK(ecode4)) {
11729  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11730  }
11731  arg4 = static_cast< PLINT >(val4);
11732  ecode5 = SWIG_AsVal_int(args(2), &val5);
11733  if (!SWIG_IsOK(ecode5)) {
11734  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11735  }
11736  arg5 = static_cast< PLINT >(val5);
11737  ecode6 = SWIG_AsVal_int(args(3), &val6);
11738  if (!SWIG_IsOK(ecode6)) {
11739  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
11740  }
11741  arg6 = static_cast< PLINT >(val6);
11742  ecode7 = SWIG_AsVal_int(args(4), &val7);
11743  if (!SWIG_IsOK(ecode7)) {
11744  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
11745  }
11746  arg7 = static_cast< PLINT >(val7);
11747  {
11748  if ( _n_dims( args(5) ) > 1 )
11749  {
11750  error( "argument must be a scalar or vector" ); SWIG_fail;
11751  }
11752  temp8 = args(5).matrix_value();
11753  arg8 = &temp8( 0, 0 );
11754  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11755  }
11756  {
11757  if ( _n_dims( args(6) ) > 2 )
11758  {
11759  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11760  }
11761  if ( _dim( args(6), 0 ) != Xlen )
11762  {
11763  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11764  }
11765  if ( _dim( args(6), 1 ) != Ylen )
11766  {
11767  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11768  }
11769  temp10 = args(6).matrix_value();
11770  arg10 = &temp10( 0, 0 );
11771  }
11772  {
11773  if ( _n_dims( args(7) ) > 2 )
11774  {
11775  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11776  }
11777  if ( _dim( args(7), 0 ) != Xlen )
11778  {
11779  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11780  }
11781  if ( _dim( args(7), 1 ) != Ylen )
11782  {
11783  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11784  }
11785  temp11 = args(7).matrix_value();
11786  arg11 = &temp11( 0, 0 );
11787  }
11788  my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11789  _outv = octave_value();
11790  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11791  {
11792 
11793  }
11794  {
11795 
11796  }
11797  {
11798 
11799  }
11800  {
11801 
11802  }
11803  return _out;
11804 fail:
11805  {
11806 
11807  }
11808  {
11809 
11810  }
11811  {
11812 
11813  }
11814  {
11815 
11816  }
11817  return octave_value_list();
11818 }
11819 
11820 
11821 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
11822  PLFLT *arg1 = (PLFLT *) 0 ;
11823  PLINT arg2 ;
11824  PLINT arg3 ;
11825  PLINT arg4 ;
11826  PLINT arg5 ;
11827  PLINT arg6 ;
11828  PLINT arg7 ;
11829  PLFLT *arg8 = (PLFLT *) 0 ;
11830  PLINT arg9 ;
11831  PLFLT *arg10 = (PLFLT *) 0 ;
11832  PLFLT *arg11 = (PLFLT *) 0 ;
11833  Matrix temp1 ;
11834  int val4 ;
11835  int ecode4 = 0 ;
11836  int val5 ;
11837  int ecode5 = 0 ;
11838  int val6 ;
11839  int ecode6 = 0 ;
11840  int val7 ;
11841  int ecode7 = 0 ;
11842  Matrix temp8 ;
11843  Matrix temp10 ;
11844  Matrix temp11 ;
11845  octave_value_list _out;
11846  octave_value_list *_outp=&_out;
11847  octave_value _outv;
11848 
11849  if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
11850  SWIG_fail;
11851  }
11852  {
11853  if ( _n_dims( args(0) ) > 2 )
11854  {
11855  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11856  }
11857  temp1 = args(0).matrix_value();
11858  arg1 = &temp1( 0, 0 );
11859  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11860  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11861  }
11862  ecode4 = SWIG_AsVal_int(args(1), &val4);
11863  if (!SWIG_IsOK(ecode4)) {
11864  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
11865  }
11866  arg4 = static_cast< PLINT >(val4);
11867  ecode5 = SWIG_AsVal_int(args(2), &val5);
11868  if (!SWIG_IsOK(ecode5)) {
11869  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
11870  }
11871  arg5 = static_cast< PLINT >(val5);
11872  ecode6 = SWIG_AsVal_int(args(3), &val6);
11873  if (!SWIG_IsOK(ecode6)) {
11874  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
11875  }
11876  arg6 = static_cast< PLINT >(val6);
11877  ecode7 = SWIG_AsVal_int(args(4), &val7);
11878  if (!SWIG_IsOK(ecode7)) {
11879  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
11880  }
11881  arg7 = static_cast< PLINT >(val7);
11882  {
11883  if ( _n_dims( args(5) ) > 1 )
11884  {
11885  error( "argument must be a scalar or vector" ); SWIG_fail;
11886  }
11887  temp8 = args(5).matrix_value();
11888  arg8 = &temp8( 0, 0 );
11889  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11890  }
11891  {
11892  if ( _n_dims( args(6) ) > 2 )
11893  {
11894  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11895  }
11896  if ( _dim( args(6), 0 ) != Xlen )
11897  {
11898  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11899  }
11900  if ( _dim( args(6), 1 ) != Ylen )
11901  {
11902  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11903  }
11904  temp10 = args(6).matrix_value();
11905  arg10 = &temp10( 0, 0 );
11906  }
11907  {
11908  if ( _n_dims( args(7) ) > 2 )
11909  {
11910  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11911  }
11912  if ( _dim( args(7), 0 ) != Xlen )
11913  {
11914  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11915  }
11916  if ( _dim( args(7), 1 ) != Ylen )
11917  {
11918  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11919  }
11920  temp11 = args(7).matrix_value();
11921  arg11 = &temp11( 0, 0 );
11922  }
11923  my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11924  _outv = octave_value();
11925  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11926  {
11927 
11928  }
11929  {
11930 
11931  }
11932  {
11933 
11934  }
11935  {
11936 
11937  }
11938  return _out;
11939 fail:
11940  {
11941 
11942  }
11943  {
11944 
11945  }
11946  {
11947 
11948  }
11949  {
11950 
11951  }
11952  return octave_value_list();
11953 }
11954 
11955 
11957  PLFLT *arg1 = (PLFLT *) 0 ;
11958  PLFLT *arg2 = (PLFLT *) 0 ;
11959  PLFLT *arg3 = (PLFLT *) 0 ;
11960  PLINT arg4 ;
11961  PLFLT *arg5 = (PLFLT *) 0 ;
11962  PLINT arg6 ;
11963  PLFLT *arg7 = (PLFLT *) 0 ;
11964  PLINT arg8 ;
11965  PLFLT *arg9 = (PLFLT *) 0 ;
11966  PLINT arg10 ;
11967  PLFLT arg11 ;
11968  Matrix temp1 ;
11969  Matrix temp2 ;
11970  Matrix temp3 ;
11971  Matrix temp5 ;
11972  Matrix temp7 ;
11973  octave_value_list retval7 ;
11974  int val10 ;
11975  int ecode10 = 0 ;
11976  double val11 ;
11977  int ecode11 = 0 ;
11978  octave_value_list _out;
11979  octave_value_list *_outp=&_out;
11980  octave_value _outv;
11981 
11982  if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
11983  SWIG_fail;
11984  }
11985  {
11986  if ( _n_dims( args(0) ) > 1 )
11987  {
11988  error( "argument must be a scalar or vector" ); SWIG_fail;
11989  }
11990  Alen = (PLINT) ( _dim( args(0), 0 ) );
11991  temp1 = args(0).matrix_value();
11992  arg1 = &temp1( 0, 0 );
11993  }
11994  {
11995  if ( _n_dims( args(1) ) > 1 )
11996  {
11997  error( "argument must be a scalar or vector" ); SWIG_fail;
11998  }
11999  if ( _dim( args(1), 0 ) != Alen )
12000  {
12001  error( "argument vectors must be same length" ); SWIG_fail;
12002  }
12003  temp2 = args(1).matrix_value();
12004  arg2 = &temp2( 0, 0 );
12005  }
12006  {
12007  if ( _n_dims( args(2) ) > 1 )
12008  {
12009  error( "argument must be a scalar or vector" ); SWIG_fail;
12010  }
12011  if ( _dim( args(2), 0 ) != Alen )
12012  {
12013  error( "argument vectors must be same length" ); SWIG_fail;
12014  }
12015  temp3 = args(2).matrix_value();
12016  arg3 = &temp3( 0, 0 );
12017  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12018  }
12019  {
12020  if ( _n_dims( args(3) ) > 1 )
12021  {
12022  error( "argument must be a scalar or vector" ); SWIG_fail;
12023  }
12024  temp5 = args(3).matrix_value();
12025  arg5 = &temp5( 0, 0 );
12026  arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12027  }
12028  {
12029  if ( _n_dims( args(4) ) > 1 )
12030  {
12031  error( "argument must be a scalar or vector" ); SWIG_fail;
12032  }
12033  temp7 = args(4).matrix_value();
12034  arg7 = &temp7( 0, 0 );
12035  arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12036  retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12037  arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12038  }
12039  ecode10 = SWIG_AsVal_int(args(5), &val10);
12040  if (!SWIG_IsOK(ecode10)) {
12041  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12042  }
12043  arg10 = static_cast< PLINT >(val10);
12044  ecode11 = SWIG_AsVal_double(args(6), &val11);
12045  if (!SWIG_IsOK(ecode11)) {
12046  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12047  }
12048  arg11 = static_cast< PLFLT >(val11);
12049  my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12050  _outv = octave_value();
12051  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12052  {
12053  _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
12054  }
12055  {
12056 
12057  }
12058  {
12059 
12060  }
12061  {
12062 
12063  }
12064  {
12065 
12066  }
12067  {
12068 
12069  }
12070  return _out;
12071 fail:
12072  {
12073 
12074  }
12075  {
12076 
12077  }
12078  {
12079 
12080  }
12081  {
12082 
12083  }
12084  {
12085 
12086  }
12087  return octave_value_list();
12088 }
12089 
12090 
12092  PLFLT *arg1 = (PLFLT *) 0 ;
12093  PLFLT *arg2 = (PLFLT *) 0 ;
12094  PLFLT *arg3 = (PLFLT *) 0 ;
12095  PLINT arg4 ;
12096  PLINT arg5 ;
12097  PLINT arg6 ;
12098  Matrix temp1 ;
12099  Matrix temp2 ;
12100  Matrix temp3 ;
12101  int val6 ;
12102  int ecode6 = 0 ;
12103  octave_value_list _out;
12104  octave_value_list *_outp=&_out;
12105  octave_value _outv;
12106 
12107  if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12108  SWIG_fail;
12109  }
12110  {
12111  if ( _n_dims( args(0) ) > 1 )
12112  {
12113  error( "argument must be a scalar or vector" ); SWIG_fail;
12114  }
12115  temp1 = args(0).matrix_value();
12116  arg1 = &temp1( 0, 0 );
12117  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12118  }
12119  {
12120  if ( _n_dims( args(1) ) > 1 )
12121  {
12122  error( "argument must be a scalar or vector" ); SWIG_fail;
12123  }
12124  temp2 = args(1).matrix_value();
12125  arg2 = &temp2( 0, 0 );
12126  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12127  }
12128  {
12129  if ( _n_dims( args(2) ) > 2 )
12130  {
12131  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12132  }
12133  if ( _dim( args(2), 0 ) != Xlen )
12134  {
12135  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12136  }
12137  if ( _dim( args(2), 1 ) != Ylen )
12138  {
12139  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12140  }
12141  temp3 = args(2).matrix_value();
12142  arg3 = &temp3( 0, 0 );
12143  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12144  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12145  }
12146  ecode6 = SWIG_AsVal_int(args(3), &val6);
12147  if (!SWIG_IsOK(ecode6)) {
12148  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12149  }
12150  arg6 = static_cast< PLINT >(val6);
12151  my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12152  _outv = octave_value();
12153  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12154  {
12155 
12156  }
12157  {
12158 
12159  }
12160  {
12161 
12162  }
12163  return _out;
12164 fail:
12165  {
12166 
12167  }
12168  {
12169 
12170  }
12171  {
12172 
12173  }
12174  return octave_value_list();
12175 }
12176 
12177 
12179  PLFLT *arg1 = (PLFLT *) 0 ;
12180  PLFLT *arg2 = (PLFLT *) 0 ;
12181  PLFLT *arg3 = (PLFLT *) 0 ;
12182  PLINT arg4 ;
12183  PLINT arg5 ;
12184  PLINT arg6 ;
12185  PLFLT *arg7 = (PLFLT *) 0 ;
12186  PLINT arg8 ;
12187  Matrix temp1 ;
12188  Matrix temp2 ;
12189  Matrix temp3 ;
12190  int val6 ;
12191  int ecode6 = 0 ;
12192  Matrix temp7 ;
12193  octave_value_list _out;
12194  octave_value_list *_outp=&_out;
12195  octave_value _outv;
12196 
12197  if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12198  SWIG_fail;
12199  }
12200  {
12201  if ( _n_dims( args(0) ) > 1 )
12202  {
12203  error( "argument must be a scalar or vector" ); SWIG_fail;
12204  }
12205  temp1 = args(0).matrix_value();
12206  arg1 = &temp1( 0, 0 );
12207  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12208  }
12209  {
12210  if ( _n_dims( args(1) ) > 1 )
12211  {
12212  error( "argument must be a scalar or vector" ); SWIG_fail;
12213  }
12214  temp2 = args(1).matrix_value();
12215  arg2 = &temp2( 0, 0 );
12216  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12217  }
12218  {
12219  if ( _n_dims( args(2) ) > 2 )
12220  {
12221  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12222  }
12223  if ( _dim( args(2), 0 ) != Xlen )
12224  {
12225  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12226  }
12227  if ( _dim( args(2), 1 ) != Ylen )
12228  {
12229  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12230  }
12231  temp3 = args(2).matrix_value();
12232  arg3 = &temp3( 0, 0 );
12233  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12234  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12235  }
12236  ecode6 = SWIG_AsVal_int(args(3), &val6);
12237  if (!SWIG_IsOK(ecode6)) {
12238  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12239  }
12240  arg6 = static_cast< PLINT >(val6);
12241  {
12242  if ( _n_dims( args(4) ) > 1 )
12243  {
12244  error( "argument must be a scalar or vector" ); SWIG_fail;
12245  }
12246  temp7 = args(4).matrix_value();
12247  arg7 = &temp7( 0, 0 );
12248  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12249  }
12250  my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12251  _outv = octave_value();
12252  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12253  {
12254 
12255  }
12256  {
12257 
12258  }
12259  {
12260 
12261  }
12262  {
12263 
12264  }
12265  return _out;
12266 fail:
12267  {
12268 
12269  }
12270  {
12271 
12272  }
12273  {
12274 
12275  }
12276  {
12277 
12278  }
12279  return octave_value_list();
12280 }
12281 
12282 
12284  PLFLT *arg1 = (PLFLT *) 0 ;
12285  PLFLT *arg2 = (PLFLT *) 0 ;
12286  PLFLT *arg3 = (PLFLT *) 0 ;
12287  PLINT arg4 ;
12288  PLINT arg5 ;
12289  PLINT arg6 ;
12290  PLBOOL arg7 ;
12291  Matrix temp1 ;
12292  Matrix temp2 ;
12293  Matrix temp3 ;
12294  int val6 ;
12295  int ecode6 = 0 ;
12296  int val7 ;
12297  int ecode7 = 0 ;
12298  octave_value_list _out;
12299  octave_value_list *_outp=&_out;
12300  octave_value _outv;
12301 
12302  if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12303  SWIG_fail;
12304  }
12305  {
12306  if ( _n_dims( args(0) ) > 1 )
12307  {
12308  error( "argument must be a scalar or vector" ); SWIG_fail;
12309  }
12310  temp1 = args(0).matrix_value();
12311  arg1 = &temp1( 0, 0 );
12312  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12313  }
12314  {
12315  if ( _n_dims( args(1) ) > 1 )
12316  {
12317  error( "argument must be a scalar or vector" ); SWIG_fail;
12318  }
12319  temp2 = args(1).matrix_value();
12320  arg2 = &temp2( 0, 0 );
12321  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12322  }
12323  {
12324  if ( _n_dims( args(2) ) > 2 )
12325  {
12326  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12327  }
12328  if ( _dim( args(2), 0 ) != Xlen )
12329  {
12330  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12331  }
12332  if ( _dim( args(2), 1 ) != Ylen )
12333  {
12334  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12335  }
12336  temp3 = args(2).matrix_value();
12337  arg3 = &temp3( 0, 0 );
12338  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12339  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12340  }
12341  ecode6 = SWIG_AsVal_int(args(3), &val6);
12342  if (!SWIG_IsOK(ecode6)) {
12343  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12344  }
12345  arg6 = static_cast< PLINT >(val6);
12346  ecode7 = SWIG_AsVal_int(args(4), &val7);
12347  if (!SWIG_IsOK(ecode7)) {
12348  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12349  }
12350  arg7 = static_cast< PLBOOL >(val7);
12351  my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12352  _outv = octave_value();
12353  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12354  {
12355 
12356  }
12357  {
12358 
12359  }
12360  {
12361 
12362  }
12363  return _out;
12364 fail:
12365  {
12366 
12367  }
12368  {
12369 
12370  }
12371  {
12372 
12373  }
12374  return octave_value_list();
12375 }
12376 
12377 
12379  PLFLT *arg1 = (PLFLT *) 0 ;
12380  PLFLT *arg2 = (PLFLT *) 0 ;
12381  PLFLT *arg3 = (PLFLT *) 0 ;
12382  PLINT arg4 ;
12383  PLINT arg5 ;
12384  PLINT arg6 ;
12385  PLFLT *arg7 = (PLFLT *) 0 ;
12386  PLINT arg8 ;
12387  Matrix temp1 ;
12388  Matrix temp2 ;
12389  Matrix temp3 ;
12390  int val6 ;
12391  int ecode6 = 0 ;
12392  Matrix temp7 ;
12393  octave_value_list _out;
12394  octave_value_list *_outp=&_out;
12395  octave_value _outv;
12396 
12397  if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12398  SWIG_fail;
12399  }
12400  {
12401  if ( _n_dims( args(0) ) > 1 )
12402  {
12403  error( "argument must be a scalar or vector" ); SWIG_fail;
12404  }
12405  temp1 = args(0).matrix_value();
12406  arg1 = &temp1( 0, 0 );
12407  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12408  }
12409  {
12410  if ( _n_dims( args(1) ) > 1 )
12411  {
12412  error( "argument must be a scalar or vector" ); SWIG_fail;
12413  }
12414  temp2 = args(1).matrix_value();
12415  arg2 = &temp2( 0, 0 );
12416  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12417  }
12418  {
12419  if ( _n_dims( args(2) ) > 2 )
12420  {
12421  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12422  }
12423  if ( _dim( args(2), 0 ) != Xlen )
12424  {
12425  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12426  }
12427  if ( _dim( args(2), 1 ) != Ylen )
12428  {
12429  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12430  }
12431  temp3 = args(2).matrix_value();
12432  arg3 = &temp3( 0, 0 );
12433  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12434  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12435  }
12436  ecode6 = SWIG_AsVal_int(args(3), &val6);
12437  if (!SWIG_IsOK(ecode6)) {
12438  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12439  }
12440  arg6 = static_cast< PLINT >(val6);
12441  {
12442  if ( _n_dims( args(4) ) > 1 )
12443  {
12444  error( "argument must be a scalar or vector" ); SWIG_fail;
12445  }
12446  temp7 = args(4).matrix_value();
12447  arg7 = &temp7( 0, 0 );
12448  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12449  }
12450  my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12451  _outv = octave_value();
12452  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12453  {
12454 
12455  }
12456  {
12457 
12458  }
12459  {
12460 
12461  }
12462  {
12463 
12464  }
12465  return _out;
12466 fail:
12467  {
12468 
12469  }
12470  {
12471 
12472  }
12473  {
12474 
12475  }
12476  {
12477 
12478  }
12479  return octave_value_list();
12480 }
12481 
12482 
12484  PLFLT *arg1 = (PLFLT *) 0 ;
12485  PLFLT *arg2 = (PLFLT *) 0 ;
12486  PLFLT *arg3 = (PLFLT *) 0 ;
12487  PLINT arg4 ;
12488  PLINT arg5 ;
12489  PLINT arg6 ;
12490  PLFLT *arg7 = (PLFLT *) 0 ;
12491  PLINT arg8 ;
12492  PLINT arg9 ;
12493  PLINT arg10 ;
12494  PLINT *arg11 = (PLINT *) 0 ;
12495  PLINT *arg12 = (PLINT *) 0 ;
12496  Matrix temp1 ;
12497  Matrix temp2 ;
12498  Matrix temp3 ;
12499  int val6 ;
12500  int ecode6 = 0 ;
12501  Matrix temp7 ;
12502  int val9 ;
12503  int ecode9 = 0 ;
12504  Matrix temp10 ;
12505  Matrix temp12 ;
12506  octave_value_list _out;
12507  octave_value_list *_outp=&_out;
12508  octave_value _outv;
12509 
12510  if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12511  SWIG_fail;
12512  }
12513  {
12514  if ( _n_dims( args(0) ) > 1 )
12515  {
12516  error( "argument must be a scalar or vector" ); SWIG_fail;
12517  }
12518  temp1 = args(0).matrix_value();
12519  arg1 = &temp1( 0, 0 );
12520  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12521  }
12522  {
12523  if ( _n_dims( args(1) ) > 1 )
12524  {
12525  error( "argument must be a scalar or vector" ); SWIG_fail;
12526  }
12527  temp2 = args(1).matrix_value();
12528  arg2 = &temp2( 0, 0 );
12529  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12530  }
12531  {
12532  if ( _n_dims( args(2) ) > 2 )
12533  {
12534  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12535  }
12536  if ( _dim( args(2), 0 ) != Xlen )
12537  {
12538  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12539  }
12540  if ( _dim( args(2), 1 ) != Ylen )
12541  {
12542  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12543  }
12544  temp3 = args(2).matrix_value();
12545  arg3 = &temp3( 0, 0 );
12546  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12547  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12548  }
12549  ecode6 = SWIG_AsVal_int(args(3), &val6);
12550  if (!SWIG_IsOK(ecode6)) {
12551  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
12552  }
12553  arg6 = static_cast< PLINT >(val6);
12554  {
12555  if ( _n_dims( args(4) ) > 1 )
12556  {
12557  error( "argument must be a scalar or vector" ); SWIG_fail;
12558  }
12559  temp7 = args(4).matrix_value();
12560  arg7 = &temp7( 0, 0 );
12561  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12562  }
12563  ecode9 = SWIG_AsVal_int(args(5), &val9);
12564  if (!SWIG_IsOK(ecode9)) {
12565  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
12566  }
12567  arg9 = static_cast< PLINT >(val9);
12568  {
12569  if ( _n_dims( args(6) ) > 1 )
12570  {
12571  error( "argument must be a scalar or vector" ); SWIG_fail;
12572  }
12573  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12574  arg11 = new PLINT[Alen];
12575  temp10 = args(6).matrix_value();
12576  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12577  }
12578  {
12579  if ( _n_dims( args(7) ) > 1 )
12580  {
12581  error( "argument must be a scalar or vector" ); SWIG_fail;
12582  }
12583  if ( _dim( args(7), 0 ) != Alen )
12584  {
12585  error( "argument vectors must be same length" ); SWIG_fail;
12586  }
12587  temp12 = args(7).matrix_value();
12588  arg12 = new PLINT[Alen];
12589  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12590  }
12591  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);
12592  _outv = octave_value();
12593  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12594  {
12595 
12596  }
12597  {
12598 
12599  }
12600  {
12601 
12602  }
12603  {
12604 
12605  }
12606  {
12607  delete [] arg11;
12608  }
12609  {
12610  delete [] arg12;
12611  }
12612  return _out;
12613 fail:
12614  {
12615 
12616  }
12617  {
12618 
12619  }
12620  {
12621 
12622  }
12623  {
12624 
12625  }
12626  {
12627  delete [] arg11;
12628  }
12629  {
12630  delete [] arg12;
12631  }
12632  return octave_value_list();
12633 }
12634 
12635 
12637  PLFLT *arg1 = (PLFLT *) 0 ;
12638  PLFLT *arg2 = (PLFLT *) 0 ;
12639  PLFLT *arg3 = (PLFLT *) 0 ;
12640  PLINT arg4 ;
12641  PLINT arg5 ;
12642  PLINT arg6 ;
12643  PLFLT *arg7 = (PLFLT *) 0 ;
12644  PLINT arg8 ;
12645  Matrix temp1 ;
12646  Matrix temp2 ;
12647  Matrix temp3 ;
12648  int val6 ;
12649  int ecode6 = 0 ;
12650  Matrix temp7 ;
12651  octave_value_list _out;
12652  octave_value_list *_outp=&_out;
12653  octave_value _outv;
12654 
12655  if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
12656  SWIG_fail;
12657  }
12658  {
12659  if ( _n_dims( args(0) ) > 1 )
12660  {
12661  error( "argument must be a scalar or vector" ); SWIG_fail;
12662  }
12663  temp1 = args(0).matrix_value();
12664  arg1 = &temp1( 0, 0 );
12665  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12666  }
12667  {
12668  if ( _n_dims( args(1) ) > 1 )
12669  {
12670  error( "argument must be a scalar or vector" ); SWIG_fail;
12671  }
12672  temp2 = args(1).matrix_value();
12673  arg2 = &temp2( 0, 0 );
12674  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12675  }
12676  {
12677  if ( _n_dims( args(2) ) > 2 )
12678  {
12679  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12680  }
12681  if ( _dim( args(2), 0 ) != Xlen )
12682  {
12683  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12684  }
12685  if ( _dim( args(2), 1 ) != Ylen )
12686  {
12687  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12688  }
12689  temp3 = args(2).matrix_value();
12690  arg3 = &temp3( 0, 0 );
12691  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12692  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12693  }
12694  ecode6 = SWIG_AsVal_int(args(3), &val6);
12695  if (!SWIG_IsOK(ecode6)) {
12696  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
12697  }
12698  arg6 = static_cast< PLINT >(val6);
12699  {
12700  if ( _n_dims( args(4) ) > 1 )
12701  {
12702  error( "argument must be a scalar or vector" ); SWIG_fail;
12703  }
12704  temp7 = args(4).matrix_value();
12705  arg7 = &temp7( 0, 0 );
12706  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12707  }
12708  my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12709  _outv = octave_value();
12710  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12711  {
12712 
12713  }
12714  {
12715 
12716  }
12717  {
12718 
12719  }
12720  {
12721 
12722  }
12723  return _out;
12724 fail:
12725  {
12726 
12727  }
12728  {
12729 
12730  }
12731  {
12732 
12733  }
12734  {
12735 
12736  }
12737  return octave_value_list();
12738 }
12739 
12740 
12742  PLFLT *arg1 = (PLFLT *) 0 ;
12743  PLFLT *arg2 = (PLFLT *) 0 ;
12744  PLFLT *arg3 = (PLFLT *) 0 ;
12745  PLINT arg4 ;
12746  PLINT arg5 ;
12747  PLINT arg6 ;
12748  PLFLT *arg7 = (PLFLT *) 0 ;
12749  PLINT arg8 ;
12750  PLINT arg9 ;
12751  PLINT arg10 ;
12752  PLINT *arg11 = (PLINT *) 0 ;
12753  PLINT *arg12 = (PLINT *) 0 ;
12754  Matrix temp1 ;
12755  Matrix temp2 ;
12756  Matrix temp3 ;
12757  int val6 ;
12758  int ecode6 = 0 ;
12759  Matrix temp7 ;
12760  int val9 ;
12761  int ecode9 = 0 ;
12762  Matrix temp10 ;
12763  Matrix temp12 ;
12764  octave_value_list _out;
12765  octave_value_list *_outp=&_out;
12766  octave_value _outv;
12767 
12768  if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
12769  SWIG_fail;
12770  }
12771  {
12772  if ( _n_dims( args(0) ) > 1 )
12773  {
12774  error( "argument must be a scalar or vector" ); SWIG_fail;
12775  }
12776  temp1 = args(0).matrix_value();
12777  arg1 = &temp1( 0, 0 );
12778  Xlen = (PLINT) ( _dim( args(0), 0 ) );
12779  }
12780  {
12781  if ( _n_dims( args(1) ) > 1 )
12782  {
12783  error( "argument must be a scalar or vector" ); SWIG_fail;
12784  }
12785  temp2 = args(1).matrix_value();
12786  arg2 = &temp2( 0, 0 );
12787  Ylen = (PLINT) ( _dim( args(1), 0 ) );
12788  }
12789  {
12790  if ( _n_dims( args(2) ) > 2 )
12791  {
12792  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12793  }
12794  if ( _dim( args(2), 0 ) != Xlen )
12795  {
12796  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12797  }
12798  if ( _dim( args(2), 1 ) != Ylen )
12799  {
12800  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12801  }
12802  temp3 = args(2).matrix_value();
12803  arg3 = &temp3( 0, 0 );
12804  arg4 = (PLINT) ( _dim( args(2), 0 ) );
12805  arg5 = (PLINT) ( _dim( args(2), 1 ) );
12806  }
12807  ecode6 = SWIG_AsVal_int(args(3), &val6);
12808  if (!SWIG_IsOK(ecode6)) {
12809  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
12810  }
12811  arg6 = static_cast< PLINT >(val6);
12812  {
12813  if ( _n_dims( args(4) ) > 1 )
12814  {
12815  error( "argument must be a scalar or vector" ); SWIG_fail;
12816  }
12817  temp7 = args(4).matrix_value();
12818  arg7 = &temp7( 0, 0 );
12819  arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12820  }
12821  ecode9 = SWIG_AsVal_int(args(5), &val9);
12822  if (!SWIG_IsOK(ecode9)) {
12823  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
12824  }
12825  arg9 = static_cast< PLINT >(val9);
12826  {
12827  if ( _n_dims( args(6) ) > 1 )
12828  {
12829  error( "argument must be a scalar or vector" ); SWIG_fail;
12830  }
12831  arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12832  arg11 = new PLINT[Alen];
12833  temp10 = args(6).matrix_value();
12834  _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12835  }
12836  {
12837  if ( _n_dims( args(7) ) > 1 )
12838  {
12839  error( "argument must be a scalar or vector" ); SWIG_fail;
12840  }
12841  if ( _dim( args(7), 0 ) != Alen )
12842  {
12843  error( "argument vectors must be same length" ); SWIG_fail;
12844  }
12845  temp12 = args(7).matrix_value();
12846  arg12 = new PLINT[Alen];
12847  _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12848  }
12849  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);
12850  _outv = octave_value();
12851  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12852  {
12853 
12854  }
12855  {
12856 
12857  }
12858  {
12859 
12860  }
12861  {
12862 
12863  }
12864  {
12865  delete [] arg11;
12866  }
12867  {
12868  delete [] arg12;
12869  }
12870  return _out;
12871 fail:
12872  {
12873 
12874  }
12875  {
12876 
12877  }
12878  {
12879 
12880  }
12881  {
12882 
12883  }
12884  {
12885  delete [] arg11;
12886  }
12887  {
12888  delete [] arg12;
12889  }
12890  return octave_value_list();
12891 }
12892 
12893 
12895  PLFLT *arg1 = (PLFLT *) 0 ;
12896  PLINT arg2 ;
12897  PLINT arg3 ;
12898  PLFLT *arg4 = (PLFLT *) 0 ;
12899  PLFLT arg5 ;
12900  PLFLT arg6 ;
12901  PLFLT arg7 ;
12902  PLFLT arg8 ;
12903  PLFLT arg9 ;
12904  PLFLT arg10 ;
12905  PLINT arg11 ;
12906  PLFLT arg12 ;
12907  PLINT arg13 ;
12908  PLINT arg14 ;
12909  PLINT arg15 ;
12910  PLINT arg16 ;
12911  PLINT arg17 ;
12912  PLBOOL arg18 ;
12913  PLFLT *arg19 = (PLFLT *) 0 ;
12914  Matrix temp1 ;
12915  Matrix temp4 ;
12916  double val5 ;
12917  int ecode5 = 0 ;
12918  double val6 ;
12919  int ecode6 = 0 ;
12920  double val7 ;
12921  int ecode7 = 0 ;
12922  double val8 ;
12923  int ecode8 = 0 ;
12924  double val9 ;
12925  int ecode9 = 0 ;
12926  double val10 ;
12927  int ecode10 = 0 ;
12928  int val11 ;
12929  int ecode11 = 0 ;
12930  double val12 ;
12931  int ecode12 = 0 ;
12932  int val13 ;
12933  int ecode13 = 0 ;
12934  int val14 ;
12935  int ecode14 = 0 ;
12936  int val15 ;
12937  int ecode15 = 0 ;
12938  int val16 ;
12939  int ecode16 = 0 ;
12940  int val17 ;
12941  int ecode17 = 0 ;
12942  int val18 ;
12943  int ecode18 = 0 ;
12944  Matrix temp19 ;
12945  octave_value_list _out;
12946  octave_value_list *_outp=&_out;
12947  octave_value _outv;
12948 
12949  if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
12950  SWIG_fail;
12951  }
12952  {
12953  if ( _n_dims( args(0) ) > 2 )
12954  {
12955  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12956  }
12957  temp1 = args(0).matrix_value();
12958  arg1 = &temp1( 0, 0 );
12959  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12960  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12961  }
12962  {
12963  if ( _n_dims( args(1) ) > 1 )
12964  {
12965  error( "argument must be a scalar or vector" ); SWIG_fail;
12966  }
12967  Alen = (PLINT) ( _dim( args(1), 0 ) );
12968  temp4 = args(1).matrix_value();
12969  arg4 = &temp4( 0, 0 );
12970  }
12971  ecode5 = SWIG_AsVal_double(args(2), &val5);
12972  if (!SWIG_IsOK(ecode5)) {
12973  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12974  }
12975  arg5 = static_cast< PLFLT >(val5);
12976  ecode6 = SWIG_AsVal_double(args(3), &val6);
12977  if (!SWIG_IsOK(ecode6)) {
12978  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12979  }
12980  arg6 = static_cast< PLFLT >(val6);
12981  ecode7 = SWIG_AsVal_double(args(4), &val7);
12982  if (!SWIG_IsOK(ecode7)) {
12983  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12984  }
12985  arg7 = static_cast< PLFLT >(val7);
12986  ecode8 = SWIG_AsVal_double(args(5), &val8);
12987  if (!SWIG_IsOK(ecode8)) {
12988  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12989  }
12990  arg8 = static_cast< PLFLT >(val8);
12991  ecode9 = SWIG_AsVal_double(args(6), &val9);
12992  if (!SWIG_IsOK(ecode9)) {
12993  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12994  }
12995  arg9 = static_cast< PLFLT >(val9);
12996  ecode10 = SWIG_AsVal_double(args(7), &val10);
12997  if (!SWIG_IsOK(ecode10)) {
12998  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12999  }
13000  arg10 = static_cast< PLFLT >(val10);
13001  ecode11 = SWIG_AsVal_int(args(8), &val11);
13002  if (!SWIG_IsOK(ecode11)) {
13003  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13004  }
13005  arg11 = static_cast< PLINT >(val11);
13006  ecode12 = SWIG_AsVal_double(args(9), &val12);
13007  if (!SWIG_IsOK(ecode12)) {
13008  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13009  }
13010  arg12 = static_cast< PLFLT >(val12);
13011  ecode13 = SWIG_AsVal_int(args(10), &val13);
13012  if (!SWIG_IsOK(ecode13)) {
13013  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13014  }
13015  arg13 = static_cast< PLINT >(val13);
13016  ecode14 = SWIG_AsVal_int(args(11), &val14);
13017  if (!SWIG_IsOK(ecode14)) {
13018  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13019  }
13020  arg14 = static_cast< PLINT >(val14);
13021  ecode15 = SWIG_AsVal_int(args(12), &val15);
13022  if (!SWIG_IsOK(ecode15)) {
13023  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13024  }
13025  arg15 = static_cast< PLINT >(val15);
13026  ecode16 = SWIG_AsVal_int(args(13), &val16);
13027  if (!SWIG_IsOK(ecode16)) {
13028  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13029  }
13030  arg16 = static_cast< PLINT >(val16);
13031  ecode17 = SWIG_AsVal_int(args(14), &val17);
13032  if (!SWIG_IsOK(ecode17)) {
13033  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13034  }
13035  arg17 = static_cast< PLINT >(val17);
13036  ecode18 = SWIG_AsVal_int(args(15), &val18);
13037  if (!SWIG_IsOK(ecode18)) {
13038  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13039  }
13040  arg18 = static_cast< PLBOOL >(val18);
13041  {
13042  if ( _n_dims( args(16) ) > 1 )
13043  {
13044  error( "argument must be a scalar or vector" ); SWIG_fail;
13045  }
13046  if ( _dim( args(16), 0 ) != 6 )
13047  {
13048  error( "argument vectors must have length of 6" ); SWIG_fail;
13049  }
13050  temp19 = args(16).matrix_value();
13051  arg19 = &temp19( 0, 0 );
13052  }
13053  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);
13054  _outv = octave_value();
13055  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13056  {
13057 
13058  }
13059  {
13060 
13061  }
13062  {
13063 
13064  }
13065  return _out;
13066 fail:
13067  {
13068 
13069  }
13070  {
13071 
13072  }
13073  {
13074 
13075  }
13076  return octave_value_list();
13077 }
13078 
13079 
13080 SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13081  PLFLT *arg1 = (PLFLT *) 0 ;
13082  PLINT arg2 ;
13083  PLINT arg3 ;
13084  char *arg4 = (char *) 0 ;
13085  PLFLT arg5 ;
13086  PLFLT arg6 ;
13087  PLFLT arg7 ;
13088  PLFLT arg8 ;
13089  PLFLT arg9 ;
13090  PLFLT arg10 ;
13091  PLINT arg11 ;
13092  PLFLT arg12 ;
13093  PLINT arg13 ;
13094  PLINT arg14 ;
13095  PLINT arg15 ;
13096  PLINT arg16 ;
13097  PLINT arg17 ;
13098  PLBOOL arg18 ;
13099  PLFLT *arg19 = (PLFLT *) 0 ;
13100  PLFLT *arg20 = (PLFLT *) 0 ;
13101  Matrix temp1 ;
13102  int res4 ;
13103  char *buf4 = 0 ;
13104  int alloc4 = 0 ;
13105  double val5 ;
13106  int ecode5 = 0 ;
13107  double val6 ;
13108  int ecode6 = 0 ;
13109  double val7 ;
13110  int ecode7 = 0 ;
13111  double val8 ;
13112  int ecode8 = 0 ;
13113  double val9 ;
13114  int ecode9 = 0 ;
13115  double val10 ;
13116  int ecode10 = 0 ;
13117  int val11 ;
13118  int ecode11 = 0 ;
13119  double val12 ;
13120  int ecode12 = 0 ;
13121  int val13 ;
13122  int ecode13 = 0 ;
13123  int val14 ;
13124  int ecode14 = 0 ;
13125  int val15 ;
13126  int ecode15 = 0 ;
13127  int val16 ;
13128  int ecode16 = 0 ;
13129  int val17 ;
13130  int ecode17 = 0 ;
13131  int val18 ;
13132  int ecode18 = 0 ;
13133  Matrix temp19 ;
13134  Matrix temp20 ;
13135  octave_value_list _out;
13136  octave_value_list *_outp=&_out;
13137  octave_value _outv;
13138 
13139  if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13140  SWIG_fail;
13141  }
13142  {
13143  if ( _n_dims( args(0) ) > 2 )
13144  {
13145  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13146  }
13147  temp1 = args(0).matrix_value();
13148  arg1 = &temp1( 0, 0 );
13149  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13150  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13151  }
13152  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13153  if (!SWIG_IsOK(res4)) {
13154  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13155  }
13156  arg4 = reinterpret_cast< char * >(buf4);
13157  ecode5 = SWIG_AsVal_double(args(2), &val5);
13158  if (!SWIG_IsOK(ecode5)) {
13159  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13160  }
13161  arg5 = static_cast< PLFLT >(val5);
13162  ecode6 = SWIG_AsVal_double(args(3), &val6);
13163  if (!SWIG_IsOK(ecode6)) {
13164  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13165  }
13166  arg6 = static_cast< PLFLT >(val6);
13167  ecode7 = SWIG_AsVal_double(args(4), &val7);
13168  if (!SWIG_IsOK(ecode7)) {
13169  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13170  }
13171  arg7 = static_cast< PLFLT >(val7);
13172  ecode8 = SWIG_AsVal_double(args(5), &val8);
13173  if (!SWIG_IsOK(ecode8)) {
13174  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13175  }
13176  arg8 = static_cast< PLFLT >(val8);
13177  ecode9 = SWIG_AsVal_double(args(6), &val9);
13178  if (!SWIG_IsOK(ecode9)) {
13179  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13180  }
13181  arg9 = static_cast< PLFLT >(val9);
13182  ecode10 = SWIG_AsVal_double(args(7), &val10);
13183  if (!SWIG_IsOK(ecode10)) {
13184  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13185  }
13186  arg10 = static_cast< PLFLT >(val10);
13187  ecode11 = SWIG_AsVal_int(args(8), &val11);
13188  if (!SWIG_IsOK(ecode11)) {
13189  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13190  }
13191  arg11 = static_cast< PLINT >(val11);
13192  ecode12 = SWIG_AsVal_double(args(9), &val12);
13193  if (!SWIG_IsOK(ecode12)) {
13194  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13195  }
13196  arg12 = static_cast< PLFLT >(val12);
13197  ecode13 = SWIG_AsVal_int(args(10), &val13);
13198  if (!SWIG_IsOK(ecode13)) {
13199  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13200  }
13201  arg13 = static_cast< PLINT >(val13);
13202  ecode14 = SWIG_AsVal_int(args(11), &val14);
13203  if (!SWIG_IsOK(ecode14)) {
13204  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13205  }
13206  arg14 = static_cast< PLINT >(val14);
13207  ecode15 = SWIG_AsVal_int(args(12), &val15);
13208  if (!SWIG_IsOK(ecode15)) {
13209  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13210  }
13211  arg15 = static_cast< PLINT >(val15);
13212  ecode16 = SWIG_AsVal_int(args(13), &val16);
13213  if (!SWIG_IsOK(ecode16)) {
13214  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13215  }
13216  arg16 = static_cast< PLINT >(val16);
13217  ecode17 = SWIG_AsVal_int(args(14), &val17);
13218  if (!SWIG_IsOK(ecode17)) {
13219  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13220  }
13221  arg17 = static_cast< PLINT >(val17);
13222  ecode18 = SWIG_AsVal_int(args(15), &val18);
13223  if (!SWIG_IsOK(ecode18)) {
13224  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13225  }
13226  arg18 = static_cast< PLBOOL >(val18);
13227  {
13228  if ( _n_dims( args(16) ) > 1 )
13229  {
13230  error( "argument must be a scalar or vector" ); SWIG_fail;
13231  }
13232  if ( _dim( args(16), 0 ) != Xlen )
13233  {
13234  error( "argument vectors must be same length" ); SWIG_fail;
13235  }
13236  temp19 = args(16).matrix_value();
13237  arg19 = &temp19( 0, 0 );
13238  }
13239  {
13240  if ( _n_dims( args(17) ) > 1 )
13241  {
13242  error( "argument must be a scalar or vector" ); SWIG_fail;
13243  }
13244  if ( _dim( args(17), 0 ) != Ylen )
13245  {
13246  error( "argument vectors must be same length" ); SWIG_fail;
13247  }
13248  temp20 = args(17).matrix_value();
13249  arg20 = &temp20( 0, 0 );
13250  }
13251  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);
13252  _outv = octave_value();
13253  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13254  {
13255 
13256  }
13257  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13258  {
13259 
13260  }
13261  {
13262 
13263  }
13264  return _out;
13265 fail:
13266  {
13267 
13268  }
13269  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13270  {
13271 
13272  }
13273  {
13274 
13275  }
13276  return octave_value_list();
13277 }
13278 
13279 
13280 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13281  PLFLT *arg1 = (PLFLT *) 0 ;
13282  PLINT arg2 ;
13283  PLINT arg3 ;
13284  char *arg4 = (char *) 0 ;
13285  PLFLT arg5 ;
13286  PLFLT arg6 ;
13287  PLFLT arg7 ;
13288  PLFLT arg8 ;
13289  PLFLT arg9 ;
13290  PLFLT arg10 ;
13291  PLINT arg11 ;
13292  PLFLT arg12 ;
13293  PLINT arg13 ;
13294  PLINT arg14 ;
13295  PLINT arg15 ;
13296  PLINT arg16 ;
13297  PLINT arg17 ;
13298  PLBOOL arg18 ;
13299  PLFLT *arg19 = (PLFLT *) 0 ;
13300  PLFLT *arg20 = (PLFLT *) 0 ;
13301  Matrix temp1 ;
13302  int res4 ;
13303  char *buf4 = 0 ;
13304  int alloc4 = 0 ;
13305  double val5 ;
13306  int ecode5 = 0 ;
13307  double val6 ;
13308  int ecode6 = 0 ;
13309  double val7 ;
13310  int ecode7 = 0 ;
13311  double val8 ;
13312  int ecode8 = 0 ;
13313  double val9 ;
13314  int ecode9 = 0 ;
13315  double val10 ;
13316  int ecode10 = 0 ;
13317  int val11 ;
13318  int ecode11 = 0 ;
13319  double val12 ;
13320  int ecode12 = 0 ;
13321  int val13 ;
13322  int ecode13 = 0 ;
13323  int val14 ;
13324  int ecode14 = 0 ;
13325  int val15 ;
13326  int ecode15 = 0 ;
13327  int val16 ;
13328  int ecode16 = 0 ;
13329  int val17 ;
13330  int ecode17 = 0 ;
13331  int val18 ;
13332  int ecode18 = 0 ;
13333  Matrix temp19 ;
13334  Matrix temp20 ;
13335  octave_value_list _out;
13336  octave_value_list *_outp=&_out;
13337  octave_value _outv;
13338 
13339  if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13340  SWIG_fail;
13341  }
13342  {
13343  if ( _n_dims( args(0) ) > 2 )
13344  {
13345  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13346  }
13347  temp1 = args(0).matrix_value();
13348  arg1 = &temp1( 0, 0 );
13349  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13350  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13351  }
13352  res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13353  if (!SWIG_IsOK(res4)) {
13354  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13355  }
13356  arg4 = reinterpret_cast< char * >(buf4);
13357  ecode5 = SWIG_AsVal_double(args(2), &val5);
13358  if (!SWIG_IsOK(ecode5)) {
13359  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13360  }
13361  arg5 = static_cast< PLFLT >(val5);
13362  ecode6 = SWIG_AsVal_double(args(3), &val6);
13363  if (!SWIG_IsOK(ecode6)) {
13364  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13365  }
13366  arg6 = static_cast< PLFLT >(val6);
13367  ecode7 = SWIG_AsVal_double(args(4), &val7);
13368  if (!SWIG_IsOK(ecode7)) {
13369  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13370  }
13371  arg7 = static_cast< PLFLT >(val7);
13372  ecode8 = SWIG_AsVal_double(args(5), &val8);
13373  if (!SWIG_IsOK(ecode8)) {
13374  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13375  }
13376  arg8 = static_cast< PLFLT >(val8);
13377  ecode9 = SWIG_AsVal_double(args(6), &val9);
13378  if (!SWIG_IsOK(ecode9)) {
13379  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13380  }
13381  arg9 = static_cast< PLFLT >(val9);
13382  ecode10 = SWIG_AsVal_double(args(7), &val10);
13383  if (!SWIG_IsOK(ecode10)) {
13384  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13385  }
13386  arg10 = static_cast< PLFLT >(val10);
13387  ecode11 = SWIG_AsVal_int(args(8), &val11);
13388  if (!SWIG_IsOK(ecode11)) {
13389  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13390  }
13391  arg11 = static_cast< PLINT >(val11);
13392  ecode12 = SWIG_AsVal_double(args(9), &val12);
13393  if (!SWIG_IsOK(ecode12)) {
13394  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13395  }
13396  arg12 = static_cast< PLFLT >(val12);
13397  ecode13 = SWIG_AsVal_int(args(10), &val13);
13398  if (!SWIG_IsOK(ecode13)) {
13399  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13400  }
13401  arg13 = static_cast< PLINT >(val13);
13402  ecode14 = SWIG_AsVal_int(args(11), &val14);
13403  if (!SWIG_IsOK(ecode14)) {
13404  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13405  }
13406  arg14 = static_cast< PLINT >(val14);
13407  ecode15 = SWIG_AsVal_int(args(12), &val15);
13408  if (!SWIG_IsOK(ecode15)) {
13409  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13410  }
13411  arg15 = static_cast< PLINT >(val15);
13412  ecode16 = SWIG_AsVal_int(args(13), &val16);
13413  if (!SWIG_IsOK(ecode16)) {
13414  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13415  }
13416  arg16 = static_cast< PLINT >(val16);
13417  ecode17 = SWIG_AsVal_int(args(14), &val17);
13418  if (!SWIG_IsOK(ecode17)) {
13419  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13420  }
13421  arg17 = static_cast< PLINT >(val17);
13422  ecode18 = SWIG_AsVal_int(args(15), &val18);
13423  if (!SWIG_IsOK(ecode18)) {
13424  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13425  }
13426  arg18 = static_cast< PLBOOL >(val18);
13427  {
13428  if ( _n_dims( args(16) ) > 2 )
13429  {
13430  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13431  }
13432  temp19 = args(16).matrix_value();
13433  arg19 = &temp19( 0, 0 );
13434  Xlen = (PLINT) ( _dim( args(16), 0 ) );
13435  Ylen = (PLINT) ( _dim( args(16), 1 ) );
13436  }
13437  {
13438  if ( _n_dims( args(17) ) > 2 )
13439  {
13440  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13441  }
13442  temp20 = args(17).matrix_value();
13443  arg20 = &temp20( 0, 0 );
13444  Xlen = (PLINT) ( _dim( args(17), 0 ) );
13445  Ylen = (PLINT) ( _dim( args(17), 1 ) );
13446  }
13447  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);
13448  _outv = octave_value();
13449  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13450  {
13451 
13452  }
13453  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13454  {
13455 
13456  }
13457  {
13458 
13459  }
13460  return _out;
13461 fail:
13462  {
13463 
13464  }
13465  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13466  {
13467 
13468  }
13469  {
13470 
13471  }
13472  return octave_value_list();
13473 }
13474 
13475 
13477  PLFLT *arg1 = (PLFLT *) 0 ;
13478  PLINT arg2 ;
13479  PLINT arg3 ;
13480  PLFLT arg4 ;
13481  PLFLT arg5 ;
13482  PLFLT arg6 ;
13483  PLFLT arg7 ;
13484  PLFLT *arg8 = (PLFLT *) 0 ;
13485  PLINT arg9 ;
13486  PLINT arg10 ;
13487  PLINT arg11 ;
13488  PLINT arg12 ;
13489  PLBOOL arg13 ;
13490  Matrix temp1 ;
13491  double val4 ;
13492  int ecode4 = 0 ;
13493  double val5 ;
13494  int ecode5 = 0 ;
13495  double val6 ;
13496  int ecode6 = 0 ;
13497  double val7 ;
13498  int ecode7 = 0 ;
13499  Matrix temp8 ;
13500  int val10 ;
13501  int ecode10 = 0 ;
13502  int val11 ;
13503  int ecode11 = 0 ;
13504  int val12 ;
13505  int ecode12 = 0 ;
13506  int val13 ;
13507  int ecode13 = 0 ;
13508  octave_value_list _out;
13509  octave_value_list *_outp=&_out;
13510  octave_value _outv;
13511 
13512  if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
13513  SWIG_fail;
13514  }
13515  {
13516  if ( _n_dims( args(0) ) > 2 )
13517  {
13518  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13519  }
13520  temp1 = args(0).matrix_value();
13521  arg1 = &temp1( 0, 0 );
13522  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13523  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13524  }
13525  ecode4 = SWIG_AsVal_double(args(1), &val4);
13526  if (!SWIG_IsOK(ecode4)) {
13527  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
13528  }
13529  arg4 = static_cast< PLFLT >(val4);
13530  ecode5 = SWIG_AsVal_double(args(2), &val5);
13531  if (!SWIG_IsOK(ecode5)) {
13532  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
13533  }
13534  arg5 = static_cast< PLFLT >(val5);
13535  ecode6 = SWIG_AsVal_double(args(3), &val6);
13536  if (!SWIG_IsOK(ecode6)) {
13537  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
13538  }
13539  arg6 = static_cast< PLFLT >(val6);
13540  ecode7 = SWIG_AsVal_double(args(4), &val7);
13541  if (!SWIG_IsOK(ecode7)) {
13542  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
13543  }
13544  arg7 = static_cast< PLFLT >(val7);
13545  {
13546  if ( _n_dims( args(5) ) > 1 )
13547  {
13548  error( "argument must be a scalar or vector" ); SWIG_fail;
13549  }
13550  temp8 = args(5).matrix_value();
13551  arg8 = &temp8( 0, 0 );
13552  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13553  }
13554  ecode10 = SWIG_AsVal_int(args(6), &val10);
13555  if (!SWIG_IsOK(ecode10)) {
13556  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
13557  }
13558  arg10 = static_cast< PLINT >(val10);
13559  ecode11 = SWIG_AsVal_int(args(7), &val11);
13560  if (!SWIG_IsOK(ecode11)) {
13561  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
13562  }
13563  arg11 = static_cast< PLINT >(val11);
13564  ecode12 = SWIG_AsVal_int(args(8), &val12);
13565  if (!SWIG_IsOK(ecode12)) {
13566  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
13567  }
13568  arg12 = static_cast< PLINT >(val12);
13569  ecode13 = SWIG_AsVal_int(args(9), &val13);
13570  if (!SWIG_IsOK(ecode13)) {
13571  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
13572  }
13573  arg13 = static_cast< PLBOOL >(val13);
13574  my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
13575  _outv = octave_value();
13576  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13577  {
13578 
13579  }
13580  {
13581 
13582  }
13583  return _out;
13584 fail:
13585  {
13586 
13587  }
13588  {
13589 
13590  }
13591  return octave_value_list();
13592 }
13593 
13594 
13595 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
13596  PLFLT *arg1 = (PLFLT *) 0 ;
13597  PLINT arg2 ;
13598  PLINT arg3 ;
13599  PLFLT arg4 ;
13600  PLFLT arg5 ;
13601  PLFLT arg6 ;
13602  PLFLT arg7 ;
13603  PLFLT *arg8 = (PLFLT *) 0 ;
13604  PLINT arg9 ;
13605  PLINT arg10 ;
13606  PLINT arg11 ;
13607  PLINT arg12 ;
13608  PLBOOL arg13 ;
13609  PLFLT *arg14 = (PLFLT *) 0 ;
13610  Matrix temp1 ;
13611  double val4 ;
13612  int ecode4 = 0 ;
13613  double val5 ;
13614  int ecode5 = 0 ;
13615  double val6 ;
13616  int ecode6 = 0 ;
13617  double val7 ;
13618  int ecode7 = 0 ;
13619  Matrix temp8 ;
13620  int val10 ;
13621  int ecode10 = 0 ;
13622  int val11 ;
13623  int ecode11 = 0 ;
13624  int val12 ;
13625  int ecode12 = 0 ;
13626  int val13 ;
13627  int ecode13 = 0 ;
13628  Matrix temp14 ;
13629  octave_value_list _out;
13630  octave_value_list *_outp=&_out;
13631  octave_value _outv;
13632 
13633  if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
13634  SWIG_fail;
13635  }
13636  {
13637  if ( _n_dims( args(0) ) > 2 )
13638  {
13639  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13640  }
13641  temp1 = args(0).matrix_value();
13642  arg1 = &temp1( 0, 0 );
13643  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13644  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13645  }
13646  ecode4 = SWIG_AsVal_double(args(1), &val4);
13647  if (!SWIG_IsOK(ecode4)) {
13648  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
13649  }
13650  arg4 = static_cast< PLFLT >(val4);
13651  ecode5 = SWIG_AsVal_double(args(2), &val5);
13652  if (!SWIG_IsOK(ecode5)) {
13653  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
13654  }
13655  arg5 = static_cast< PLFLT >(val5);
13656  ecode6 = SWIG_AsVal_double(args(3), &val6);
13657  if (!SWIG_IsOK(ecode6)) {
13658  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
13659  }
13660  arg6 = static_cast< PLFLT >(val6);
13661  ecode7 = SWIG_AsVal_double(args(4), &val7);
13662  if (!SWIG_IsOK(ecode7)) {
13663  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
13664  }
13665  arg7 = static_cast< PLFLT >(val7);
13666  {
13667  if ( _n_dims( args(5) ) > 1 )
13668  {
13669  error( "argument must be a scalar or vector" ); SWIG_fail;
13670  }
13671  temp8 = args(5).matrix_value();
13672  arg8 = &temp8( 0, 0 );
13673  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13674  }
13675  ecode10 = SWIG_AsVal_int(args(6), &val10);
13676  if (!SWIG_IsOK(ecode10)) {
13677  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
13678  }
13679  arg10 = static_cast< PLINT >(val10);
13680  ecode11 = SWIG_AsVal_int(args(7), &val11);
13681  if (!SWIG_IsOK(ecode11)) {
13682  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
13683  }
13684  arg11 = static_cast< PLINT >(val11);
13685  ecode12 = SWIG_AsVal_int(args(8), &val12);
13686  if (!SWIG_IsOK(ecode12)) {
13687  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
13688  }
13689  arg12 = static_cast< PLINT >(val12);
13690  ecode13 = SWIG_AsVal_int(args(9), &val13);
13691  if (!SWIG_IsOK(ecode13)) {
13692  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
13693  }
13694  arg13 = static_cast< PLBOOL >(val13);
13695  {
13696  if ( _n_dims( args(10) ) > 1 )
13697  {
13698  error( "argument must be a scalar or vector" ); SWIG_fail;
13699  }
13700  if ( _dim( args(10), 0 ) != 6 )
13701  {
13702  error( "argument vectors must have length of 6" ); SWIG_fail;
13703  }
13704  temp14 = args(10).matrix_value();
13705  arg14 = &temp14( 0, 0 );
13706  }
13707  my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
13708  _outv = octave_value();
13709  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13710  {
13711 
13712  }
13713  {
13714 
13715  }
13716  {
13717 
13718  }
13719  return _out;
13720 fail:
13721  {
13722 
13723  }
13724  {
13725 
13726  }
13727  {
13728 
13729  }
13730  return octave_value_list();
13731 }
13732 
13733 
13734 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
13735  PLFLT *arg1 = (PLFLT *) 0 ;
13736  PLINT arg2 ;
13737  PLINT arg3 ;
13738  PLFLT arg4 ;
13739  PLFLT arg5 ;
13740  PLFLT arg6 ;
13741  PLFLT arg7 ;
13742  PLFLT *arg8 = (PLFLT *) 0 ;
13743  PLINT arg9 ;
13744  PLINT arg10 ;
13745  PLINT arg11 ;
13746  PLINT arg12 ;
13747  PLBOOL arg13 ;
13748  PLFLT *arg14 = (PLFLT *) 0 ;
13749  PLFLT *arg15 = (PLFLT *) 0 ;
13750  Matrix temp1 ;
13751  double val4 ;
13752  int ecode4 = 0 ;
13753  double val5 ;
13754  int ecode5 = 0 ;
13755  double val6 ;
13756  int ecode6 = 0 ;
13757  double val7 ;
13758  int ecode7 = 0 ;
13759  Matrix temp8 ;
13760  int val10 ;
13761  int ecode10 = 0 ;
13762  int val11 ;
13763  int ecode11 = 0 ;
13764  int val12 ;
13765  int ecode12 = 0 ;
13766  int val13 ;
13767  int ecode13 = 0 ;
13768  Matrix temp14 ;
13769  Matrix temp15 ;
13770  octave_value_list _out;
13771  octave_value_list *_outp=&_out;
13772  octave_value _outv;
13773 
13774  if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
13775  SWIG_fail;
13776  }
13777  {
13778  if ( _n_dims( args(0) ) > 2 )
13779  {
13780  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13781  }
13782  temp1 = args(0).matrix_value();
13783  arg1 = &temp1( 0, 0 );
13784  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13785  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13786  }
13787  ecode4 = SWIG_AsVal_double(args(1), &val4);
13788  if (!SWIG_IsOK(ecode4)) {
13789  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
13790  }
13791  arg4 = static_cast< PLFLT >(val4);
13792  ecode5 = SWIG_AsVal_double(args(2), &val5);
13793  if (!SWIG_IsOK(ecode5)) {
13794  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
13795  }
13796  arg5 = static_cast< PLFLT >(val5);
13797  ecode6 = SWIG_AsVal_double(args(3), &val6);
13798  if (!SWIG_IsOK(ecode6)) {
13799  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
13800  }
13801  arg6 = static_cast< PLFLT >(val6);
13802  ecode7 = SWIG_AsVal_double(args(4), &val7);
13803  if (!SWIG_IsOK(ecode7)) {
13804  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
13805  }
13806  arg7 = static_cast< PLFLT >(val7);
13807  {
13808  if ( _n_dims( args(5) ) > 1 )
13809  {
13810  error( "argument must be a scalar or vector" ); SWIG_fail;
13811  }
13812  temp8 = args(5).matrix_value();
13813  arg8 = &temp8( 0, 0 );
13814  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13815  }
13816  ecode10 = SWIG_AsVal_int(args(6), &val10);
13817  if (!SWIG_IsOK(ecode10)) {
13818  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
13819  }
13820  arg10 = static_cast< PLINT >(val10);
13821  ecode11 = SWIG_AsVal_int(args(7), &val11);
13822  if (!SWIG_IsOK(ecode11)) {
13823  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
13824  }
13825  arg11 = static_cast< PLINT >(val11);
13826  ecode12 = SWIG_AsVal_int(args(8), &val12);
13827  if (!SWIG_IsOK(ecode12)) {
13828  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
13829  }
13830  arg12 = static_cast< PLINT >(val12);
13831  ecode13 = SWIG_AsVal_int(args(9), &val13);
13832  if (!SWIG_IsOK(ecode13)) {
13833  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
13834  }
13835  arg13 = static_cast< PLBOOL >(val13);
13836  {
13837  if ( _n_dims( args(10) ) > 1 )
13838  {
13839  error( "argument must be a scalar or vector" ); SWIG_fail;
13840  }
13841  if ( _dim( args(10), 0 ) != Xlen )
13842  {
13843  error( "argument vectors must be same length" ); SWIG_fail;
13844  }
13845  temp14 = args(10).matrix_value();
13846  arg14 = &temp14( 0, 0 );
13847  }
13848  {
13849  if ( _n_dims( args(11) ) > 1 )
13850  {
13851  error( "argument must be a scalar or vector" ); SWIG_fail;
13852  }
13853  if ( _dim( args(11), 0 ) != Ylen )
13854  {
13855  error( "argument vectors must be same length" ); SWIG_fail;
13856  }
13857  temp15 = args(11).matrix_value();
13858  arg15 = &temp15( 0, 0 );
13859  }
13860  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);
13861  _outv = octave_value();
13862  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13863  {
13864 
13865  }
13866  {
13867 
13868  }
13869  {
13870 
13871  }
13872  {
13873 
13874  }
13875  return _out;
13876 fail:
13877  {
13878 
13879  }
13880  {
13881 
13882  }
13883  {
13884 
13885  }
13886  {
13887 
13888  }
13889  return octave_value_list();
13890 }
13891 
13892 
13893 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
13894  PLFLT *arg1 = (PLFLT *) 0 ;
13895  PLINT arg2 ;
13896  PLINT arg3 ;
13897  PLFLT arg4 ;
13898  PLFLT arg5 ;
13899  PLFLT arg6 ;
13900  PLFLT arg7 ;
13901  PLFLT *arg8 = (PLFLT *) 0 ;
13902  PLINT arg9 ;
13903  PLINT arg10 ;
13904  PLINT arg11 ;
13905  PLINT arg12 ;
13906  PLBOOL arg13 ;
13907  PLFLT *arg14 = (PLFLT *) 0 ;
13908  PLFLT *arg15 = (PLFLT *) 0 ;
13909  Matrix temp1 ;
13910  double val4 ;
13911  int ecode4 = 0 ;
13912  double val5 ;
13913  int ecode5 = 0 ;
13914  double val6 ;
13915  int ecode6 = 0 ;
13916  double val7 ;
13917  int ecode7 = 0 ;
13918  Matrix temp8 ;
13919  int val10 ;
13920  int ecode10 = 0 ;
13921  int val11 ;
13922  int ecode11 = 0 ;
13923  int val12 ;
13924  int ecode12 = 0 ;
13925  int val13 ;
13926  int ecode13 = 0 ;
13927  Matrix temp14 ;
13928  Matrix temp15 ;
13929  octave_value_list _out;
13930  octave_value_list *_outp=&_out;
13931  octave_value _outv;
13932 
13933  if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
13934  SWIG_fail;
13935  }
13936  {
13937  if ( _n_dims( args(0) ) > 2 )
13938  {
13939  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13940  }
13941  temp1 = args(0).matrix_value();
13942  arg1 = &temp1( 0, 0 );
13943  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13944  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13945  }
13946  ecode4 = SWIG_AsVal_double(args(1), &val4);
13947  if (!SWIG_IsOK(ecode4)) {
13948  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
13949  }
13950  arg4 = static_cast< PLFLT >(val4);
13951  ecode5 = SWIG_AsVal_double(args(2), &val5);
13952  if (!SWIG_IsOK(ecode5)) {
13953  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
13954  }
13955  arg5 = static_cast< PLFLT >(val5);
13956  ecode6 = SWIG_AsVal_double(args(3), &val6);
13957  if (!SWIG_IsOK(ecode6)) {
13958  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
13959  }
13960  arg6 = static_cast< PLFLT >(val6);
13961  ecode7 = SWIG_AsVal_double(args(4), &val7);
13962  if (!SWIG_IsOK(ecode7)) {
13963  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
13964  }
13965  arg7 = static_cast< PLFLT >(val7);
13966  {
13967  if ( _n_dims( args(5) ) > 1 )
13968  {
13969  error( "argument must be a scalar or vector" ); SWIG_fail;
13970  }
13971  temp8 = args(5).matrix_value();
13972  arg8 = &temp8( 0, 0 );
13973  arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13974  }
13975  ecode10 = SWIG_AsVal_int(args(6), &val10);
13976  if (!SWIG_IsOK(ecode10)) {
13977  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
13978  }
13979  arg10 = static_cast< PLINT >(val10);
13980  ecode11 = SWIG_AsVal_int(args(7), &val11);
13981  if (!SWIG_IsOK(ecode11)) {
13982  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
13983  }
13984  arg11 = static_cast< PLINT >(val11);
13985  ecode12 = SWIG_AsVal_int(args(8), &val12);
13986  if (!SWIG_IsOK(ecode12)) {
13987  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
13988  }
13989  arg12 = static_cast< PLINT >(val12);
13990  ecode13 = SWIG_AsVal_int(args(9), &val13);
13991  if (!SWIG_IsOK(ecode13)) {
13992  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
13993  }
13994  arg13 = static_cast< PLBOOL >(val13);
13995  {
13996  if ( _n_dims( args(10) ) > 2 )
13997  {
13998  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13999  }
14000  temp14 = args(10).matrix_value();
14001  arg14 = &temp14( 0, 0 );
14002  Xlen = (PLINT) ( _dim( args(10), 0 ) );
14003  Ylen = (PLINT) ( _dim( args(10), 1 ) );
14004  }
14005  {
14006  if ( _n_dims( args(11) ) > 2 )
14007  {
14008  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14009  }
14010  temp15 = args(11).matrix_value();
14011  arg15 = &temp15( 0, 0 );
14012  Xlen = (PLINT) ( _dim( args(11), 0 ) );
14013  Ylen = (PLINT) ( _dim( args(11), 1 ) );
14014  }
14015  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);
14016  _outv = octave_value();
14017  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14018  {
14019 
14020  }
14021  {
14022 
14023  }
14024  {
14025 
14026  }
14027  {
14028 
14029  }
14030  return _out;
14031 fail:
14032  {
14033 
14034  }
14035  {
14036 
14037  }
14038  {
14039 
14040  }
14041  {
14042 
14043  }
14044  return octave_value_list();
14045 }
14046 
14047 
14049  PLFLT *arg1 = (PLFLT *) 0 ;
14050  PLFLT *arg2 = (PLFLT *) 0 ;
14051  PLINT arg3 ;
14052  PLINT arg4 ;
14053  PLFLT arg5 ;
14054  PLFLT *arg6 = (PLFLT *) 0 ;
14055  Matrix temp1 ;
14056  Matrix temp2 ;
14057  double val5 ;
14058  int ecode5 = 0 ;
14059  Matrix temp6 ;
14060  octave_value_list _out;
14061  octave_value_list *_outp=&_out;
14062  octave_value _outv;
14063 
14064  if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14065  SWIG_fail;
14066  }
14067  {
14068  if ( _n_dims( args(0) ) > 2 )
14069  {
14070  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14071  }
14072  temp1 = args(0).matrix_value();
14073  arg1 = &temp1( 0, 0 );
14074  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14075  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14076  }
14077  {
14078  if ( _n_dims( args(1) ) > 2 )
14079  {
14080  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14081  }
14082  if ( _dim( args(1), 0 ) != Xlen )
14083  {
14084  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14085  }
14086  if ( _dim( args(1), 1 ) != Ylen )
14087  {
14088  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14089  }
14090  temp2 = args(1).matrix_value();
14091  arg2 = &temp2( 0, 0 );
14092  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14093  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14094  }
14095  ecode5 = SWIG_AsVal_double(args(2), &val5);
14096  if (!SWIG_IsOK(ecode5)) {
14097  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14098  }
14099  arg5 = static_cast< PLFLT >(val5);
14100  {
14101  if ( _n_dims( args(3) ) > 1 )
14102  {
14103  error( "argument must be a scalar or vector" ); SWIG_fail;
14104  }
14105  if ( _dim( args(3), 0 ) != 6 )
14106  {
14107  error( "argument vectors must have length of 6" ); SWIG_fail;
14108  }
14109  temp6 = args(3).matrix_value();
14110  arg6 = &temp6( 0, 0 );
14111  }
14112  my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14113  _outv = octave_value();
14114  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14115  {
14116 
14117  }
14118  {
14119 
14120  }
14121  {
14122 
14123  }
14124  return _out;
14125 fail:
14126  {
14127 
14128  }
14129  {
14130 
14131  }
14132  {
14133 
14134  }
14135  return octave_value_list();
14136 }
14137 
14138 
14139 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14140  PLFLT *arg1 = (PLFLT *) 0 ;
14141  PLFLT *arg2 = (PLFLT *) 0 ;
14142  PLINT arg3 ;
14143  PLINT arg4 ;
14144  PLFLT arg5 ;
14145  PLFLT *arg6 = (PLFLT *) 0 ;
14146  PLFLT *arg7 = (PLFLT *) 0 ;
14147  Matrix temp1 ;
14148  Matrix temp2 ;
14149  double val5 ;
14150  int ecode5 = 0 ;
14151  Matrix temp6 ;
14152  Matrix temp7 ;
14153  octave_value_list _out;
14154  octave_value_list *_outp=&_out;
14155  octave_value _outv;
14156 
14157  if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14158  SWIG_fail;
14159  }
14160  {
14161  if ( _n_dims( args(0) ) > 2 )
14162  {
14163  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14164  }
14165  temp1 = args(0).matrix_value();
14166  arg1 = &temp1( 0, 0 );
14167  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14168  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14169  }
14170  {
14171  if ( _n_dims( args(1) ) > 2 )
14172  {
14173  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14174  }
14175  if ( _dim( args(1), 0 ) != Xlen )
14176  {
14177  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14178  }
14179  if ( _dim( args(1), 1 ) != Ylen )
14180  {
14181  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14182  }
14183  temp2 = args(1).matrix_value();
14184  arg2 = &temp2( 0, 0 );
14185  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14186  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14187  }
14188  ecode5 = SWIG_AsVal_double(args(2), &val5);
14189  if (!SWIG_IsOK(ecode5)) {
14190  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14191  }
14192  arg5 = static_cast< PLFLT >(val5);
14193  {
14194  if ( _n_dims( args(3) ) > 1 )
14195  {
14196  error( "argument must be a scalar or vector" ); SWIG_fail;
14197  }
14198  if ( _dim( args(3), 0 ) != Xlen )
14199  {
14200  error( "argument vectors must be same length" ); SWIG_fail;
14201  }
14202  temp6 = args(3).matrix_value();
14203  arg6 = &temp6( 0, 0 );
14204  }
14205  {
14206  if ( _n_dims( args(4) ) > 1 )
14207  {
14208  error( "argument must be a scalar or vector" ); SWIG_fail;
14209  }
14210  if ( _dim( args(4), 0 ) != Ylen )
14211  {
14212  error( "argument vectors must be same length" ); SWIG_fail;
14213  }
14214  temp7 = args(4).matrix_value();
14215  arg7 = &temp7( 0, 0 );
14216  }
14217  my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14218  _outv = octave_value();
14219  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14220  {
14221 
14222  }
14223  {
14224 
14225  }
14226  {
14227 
14228  }
14229  {
14230 
14231  }
14232  return _out;
14233 fail:
14234  {
14235 
14236  }
14237  {
14238 
14239  }
14240  {
14241 
14242  }
14243  {
14244 
14245  }
14246  return octave_value_list();
14247 }
14248 
14249 
14250 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14251  PLFLT *arg1 = (PLFLT *) 0 ;
14252  PLFLT *arg2 = (PLFLT *) 0 ;
14253  PLINT arg3 ;
14254  PLINT arg4 ;
14255  PLFLT arg5 ;
14256  PLFLT *arg6 = (PLFLT *) 0 ;
14257  PLFLT *arg7 = (PLFLT *) 0 ;
14258  Matrix temp1 ;
14259  Matrix temp2 ;
14260  double val5 ;
14261  int ecode5 = 0 ;
14262  Matrix temp6 ;
14263  Matrix temp7 ;
14264  octave_value_list _out;
14265  octave_value_list *_outp=&_out;
14266  octave_value _outv;
14267 
14268  if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14269  SWIG_fail;
14270  }
14271  {
14272  if ( _n_dims( args(0) ) > 2 )
14273  {
14274  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14275  }
14276  temp1 = args(0).matrix_value();
14277  arg1 = &temp1( 0, 0 );
14278  Xlen = (PLINT) ( _dim( args(0), 0 ) );
14279  Ylen = (PLINT) ( _dim( args(0), 1 ) );
14280  }
14281  {
14282  if ( _n_dims( args(1) ) > 2 )
14283  {
14284  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14285  }
14286  if ( _dim( args(1), 0 ) != Xlen )
14287  {
14288  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14289  }
14290  if ( _dim( args(1), 1 ) != Ylen )
14291  {
14292  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14293  }
14294  temp2 = args(1).matrix_value();
14295  arg2 = &temp2( 0, 0 );
14296  arg3 = (PLINT) ( _dim( args(1), 0 ) );
14297  arg4 = (PLINT) ( _dim( args(1), 1 ) );
14298  }
14299  ecode5 = SWIG_AsVal_double(args(2), &val5);
14300  if (!SWIG_IsOK(ecode5)) {
14301  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14302  }
14303  arg5 = static_cast< PLFLT >(val5);
14304  {
14305  if ( _n_dims( args(3) ) > 2 )
14306  {
14307  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14308  }
14309  temp6 = args(3).matrix_value();
14310  arg6 = &temp6( 0, 0 );
14311  Xlen = (PLINT) ( _dim( args(3), 0 ) );
14312  Ylen = (PLINT) ( _dim( args(3), 1 ) );
14313  }
14314  {
14315  if ( _n_dims( args(4) ) > 2 )
14316  {
14317  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14318  }
14319  temp7 = args(4).matrix_value();
14320  arg7 = &temp7( 0, 0 );
14321  Xlen = (PLINT) ( _dim( args(4), 0 ) );
14322  Ylen = (PLINT) ( _dim( args(4), 1 ) );
14323  }
14324  my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14325  _outv = octave_value();
14326  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14327  {
14328 
14329  }
14330  {
14331 
14332  }
14333  {
14334 
14335  }
14336  {
14337 
14338  }
14339  return _out;
14340 fail:
14341  {
14342 
14343  }
14344  {
14345 
14346  }
14347  {
14348 
14349  }
14350  {
14351 
14352  }
14353  return octave_value_list();
14354 }
14355 
14356 
14357 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
14358  PLFLT *arg1 = (PLFLT *) 0 ;
14359  PLINT arg2 ;
14360  PLINT arg3 ;
14361  PLFLT arg4 ;
14362  PLFLT arg5 ;
14363  PLFLT arg6 ;
14364  PLFLT arg7 ;
14365  PLFLT arg8 ;
14366  PLFLT arg9 ;
14367  PLFLT arg10 ;
14368  PLFLT arg11 ;
14369  PLFLT arg12 ;
14370  PLFLT arg13 ;
14371  Matrix temp1 ;
14372  double val4 ;
14373  int ecode4 = 0 ;
14374  double val5 ;
14375  int ecode5 = 0 ;
14376  double val6 ;
14377  int ecode6 = 0 ;
14378  double val7 ;
14379  int ecode7 = 0 ;
14380  double val8 ;
14381  int ecode8 = 0 ;
14382  double val9 ;
14383  int ecode9 = 0 ;
14384  double val10 ;
14385  int ecode10 = 0 ;
14386  double val11 ;
14387  int ecode11 = 0 ;
14388  double val12 ;
14389  int ecode12 = 0 ;
14390  double val13 ;
14391  int ecode13 = 0 ;
14392  octave_value_list _out;
14393  octave_value_list *_outp=&_out;
14394  octave_value _outv;
14395 
14396  if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
14397  SWIG_fail;
14398  }
14399  {
14400  if ( _n_dims( args(0) ) > 2 )
14401  {
14402  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14403  }
14404  temp1 = args(0).matrix_value();
14405  arg1 = &temp1( 0, 0 );
14406  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14407  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14408  }
14409  ecode4 = SWIG_AsVal_double(args(1), &val4);
14410  if (!SWIG_IsOK(ecode4)) {
14411  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
14412  }
14413  arg4 = static_cast< PLFLT >(val4);
14414  ecode5 = SWIG_AsVal_double(args(2), &val5);
14415  if (!SWIG_IsOK(ecode5)) {
14416  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
14417  }
14418  arg5 = static_cast< PLFLT >(val5);
14419  ecode6 = SWIG_AsVal_double(args(3), &val6);
14420  if (!SWIG_IsOK(ecode6)) {
14421  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
14422  }
14423  arg6 = static_cast< PLFLT >(val6);
14424  ecode7 = SWIG_AsVal_double(args(4), &val7);
14425  if (!SWIG_IsOK(ecode7)) {
14426  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
14427  }
14428  arg7 = static_cast< PLFLT >(val7);
14429  ecode8 = SWIG_AsVal_double(args(5), &val8);
14430  if (!SWIG_IsOK(ecode8)) {
14431  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
14432  }
14433  arg8 = static_cast< PLFLT >(val8);
14434  ecode9 = SWIG_AsVal_double(args(6), &val9);
14435  if (!SWIG_IsOK(ecode9)) {
14436  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
14437  }
14438  arg9 = static_cast< PLFLT >(val9);
14439  ecode10 = SWIG_AsVal_double(args(7), &val10);
14440  if (!SWIG_IsOK(ecode10)) {
14441  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
14442  }
14443  arg10 = static_cast< PLFLT >(val10);
14444  ecode11 = SWIG_AsVal_double(args(8), &val11);
14445  if (!SWIG_IsOK(ecode11)) {
14446  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
14447  }
14448  arg11 = static_cast< PLFLT >(val11);
14449  ecode12 = SWIG_AsVal_double(args(9), &val12);
14450  if (!SWIG_IsOK(ecode12)) {
14451  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
14452  }
14453  arg12 = static_cast< PLFLT >(val12);
14454  ecode13 = SWIG_AsVal_double(args(10), &val13);
14455  if (!SWIG_IsOK(ecode13)) {
14456  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
14457  }
14458  arg13 = static_cast< PLFLT >(val13);
14459  my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14460  _outv = octave_value();
14461  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14462  {
14463 
14464  }
14465  return _out;
14466 fail:
14467  {
14468 
14469  }
14470  return octave_value_list();
14471 }
14472 
14473 
14475  PLFLT *arg1 = (PLFLT *) 0 ;
14476  PLINT arg2 ;
14477  PLINT arg3 ;
14478  PLFLT arg4 ;
14479  PLFLT arg5 ;
14480  PLFLT arg6 ;
14481  PLFLT arg7 ;
14482  PLFLT arg8 ;
14483  PLFLT arg9 ;
14484  PLFLT arg10 ;
14485  PLFLT arg11 ;
14486  Matrix temp1 ;
14487  double val4 ;
14488  int ecode4 = 0 ;
14489  double val5 ;
14490  int ecode5 = 0 ;
14491  double val6 ;
14492  int ecode6 = 0 ;
14493  double val7 ;
14494  int ecode7 = 0 ;
14495  double val8 ;
14496  int ecode8 = 0 ;
14497  double val9 ;
14498  int ecode9 = 0 ;
14499  double val10 ;
14500  int ecode10 = 0 ;
14501  double val11 ;
14502  int ecode11 = 0 ;
14503  octave_value_list _out;
14504  octave_value_list *_outp=&_out;
14505  octave_value _outv;
14506 
14507  if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
14508  SWIG_fail;
14509  }
14510  {
14511  if ( _n_dims( args(0) ) > 2 )
14512  {
14513  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14514  }
14515  temp1 = args(0).matrix_value();
14516  arg1 = &temp1( 0, 0 );
14517  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14518  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14519  }
14520  ecode4 = SWIG_AsVal_double(args(1), &val4);
14521  if (!SWIG_IsOK(ecode4)) {
14522  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14523  }
14524  arg4 = static_cast< PLFLT >(val4);
14525  ecode5 = SWIG_AsVal_double(args(2), &val5);
14526  if (!SWIG_IsOK(ecode5)) {
14527  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14528  }
14529  arg5 = static_cast< PLFLT >(val5);
14530  ecode6 = SWIG_AsVal_double(args(3), &val6);
14531  if (!SWIG_IsOK(ecode6)) {
14532  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14533  }
14534  arg6 = static_cast< PLFLT >(val6);
14535  ecode7 = SWIG_AsVal_double(args(4), &val7);
14536  if (!SWIG_IsOK(ecode7)) {
14537  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14538  }
14539  arg7 = static_cast< PLFLT >(val7);
14540  ecode8 = SWIG_AsVal_double(args(5), &val8);
14541  if (!SWIG_IsOK(ecode8)) {
14542  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14543  }
14544  arg8 = static_cast< PLFLT >(val8);
14545  ecode9 = SWIG_AsVal_double(args(6), &val9);
14546  if (!SWIG_IsOK(ecode9)) {
14547  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14548  }
14549  arg9 = static_cast< PLFLT >(val9);
14550  ecode10 = SWIG_AsVal_double(args(7), &val10);
14551  if (!SWIG_IsOK(ecode10)) {
14552  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14553  }
14554  arg10 = static_cast< PLFLT >(val10);
14555  ecode11 = SWIG_AsVal_double(args(8), &val11);
14556  if (!SWIG_IsOK(ecode11)) {
14557  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14558  }
14559  arg11 = static_cast< PLFLT >(val11);
14560  my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14561  _outv = octave_value();
14562  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14563  {
14564 
14565  }
14566  return _out;
14567 fail:
14568  {
14569 
14570  }
14571  return octave_value_list();
14572 }
14573 
14574 
14575 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
14576  PLFLT *arg1 = (PLFLT *) 0 ;
14577  PLINT arg2 ;
14578  PLINT arg3 ;
14579  PLFLT arg4 ;
14580  PLFLT arg5 ;
14581  PLFLT arg6 ;
14582  PLFLT arg7 ;
14583  PLFLT arg8 ;
14584  PLFLT arg9 ;
14585  PLFLT arg10 ;
14586  PLFLT arg11 ;
14587  PLFLT *arg12 = (PLFLT *) 0 ;
14588  Matrix temp1 ;
14589  double val4 ;
14590  int ecode4 = 0 ;
14591  double val5 ;
14592  int ecode5 = 0 ;
14593  double val6 ;
14594  int ecode6 = 0 ;
14595  double val7 ;
14596  int ecode7 = 0 ;
14597  double val8 ;
14598  int ecode8 = 0 ;
14599  double val9 ;
14600  int ecode9 = 0 ;
14601  double val10 ;
14602  int ecode10 = 0 ;
14603  double val11 ;
14604  int ecode11 = 0 ;
14605  Matrix temp12 ;
14606  octave_value_list _out;
14607  octave_value_list *_outp=&_out;
14608  octave_value _outv;
14609 
14610  if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
14611  SWIG_fail;
14612  }
14613  {
14614  if ( _n_dims( args(0) ) > 2 )
14615  {
14616  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14617  }
14618  temp1 = args(0).matrix_value();
14619  arg1 = &temp1( 0, 0 );
14620  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14621  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14622  }
14623  ecode4 = SWIG_AsVal_double(args(1), &val4);
14624  if (!SWIG_IsOK(ecode4)) {
14625  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
14626  }
14627  arg4 = static_cast< PLFLT >(val4);
14628  ecode5 = SWIG_AsVal_double(args(2), &val5);
14629  if (!SWIG_IsOK(ecode5)) {
14630  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
14631  }
14632  arg5 = static_cast< PLFLT >(val5);
14633  ecode6 = SWIG_AsVal_double(args(3), &val6);
14634  if (!SWIG_IsOK(ecode6)) {
14635  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
14636  }
14637  arg6 = static_cast< PLFLT >(val6);
14638  ecode7 = SWIG_AsVal_double(args(4), &val7);
14639  if (!SWIG_IsOK(ecode7)) {
14640  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
14641  }
14642  arg7 = static_cast< PLFLT >(val7);
14643  ecode8 = SWIG_AsVal_double(args(5), &val8);
14644  if (!SWIG_IsOK(ecode8)) {
14645  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
14646  }
14647  arg8 = static_cast< PLFLT >(val8);
14648  ecode9 = SWIG_AsVal_double(args(6), &val9);
14649  if (!SWIG_IsOK(ecode9)) {
14650  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
14651  }
14652  arg9 = static_cast< PLFLT >(val9);
14653  ecode10 = SWIG_AsVal_double(args(7), &val10);
14654  if (!SWIG_IsOK(ecode10)) {
14655  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
14656  }
14657  arg10 = static_cast< PLFLT >(val10);
14658  ecode11 = SWIG_AsVal_double(args(8), &val11);
14659  if (!SWIG_IsOK(ecode11)) {
14660  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
14661  }
14662  arg11 = static_cast< PLFLT >(val11);
14663  {
14664  if ( _n_dims( args(9) ) > 1 )
14665  {
14666  error( "argument must be a scalar or vector" ); SWIG_fail;
14667  }
14668  if ( _dim( args(9), 0 ) != 6 )
14669  {
14670  error( "argument vectors must have length of 6" ); SWIG_fail;
14671  }
14672  temp12 = args(9).matrix_value();
14673  arg12 = &temp12( 0, 0 );
14674  }
14675  my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14676  _outv = octave_value();
14677  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14678  {
14679 
14680  }
14681  {
14682 
14683  }
14684  return _out;
14685 fail:
14686  {
14687 
14688  }
14689  {
14690 
14691  }
14692  return octave_value_list();
14693 }
14694 
14695 
14696 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
14697  PLFLT *arg1 = (PLFLT *) 0 ;
14698  PLINT arg2 ;
14699  PLINT arg3 ;
14700  PLFLT arg4 ;
14701  PLFLT arg5 ;
14702  PLFLT arg6 ;
14703  PLFLT arg7 ;
14704  PLFLT arg8 ;
14705  PLFLT arg9 ;
14706  PLFLT arg10 ;
14707  PLFLT arg11 ;
14708  PLFLT *arg12 = (PLFLT *) 0 ;
14709  PLFLT *arg13 = (PLFLT *) 0 ;
14710  Matrix temp1 ;
14711  double val4 ;
14712  int ecode4 = 0 ;
14713  double val5 ;
14714  int ecode5 = 0 ;
14715  double val6 ;
14716  int ecode6 = 0 ;
14717  double val7 ;
14718  int ecode7 = 0 ;
14719  double val8 ;
14720  int ecode8 = 0 ;
14721  double val9 ;
14722  int ecode9 = 0 ;
14723  double val10 ;
14724  int ecode10 = 0 ;
14725  double val11 ;
14726  int ecode11 = 0 ;
14727  Matrix temp12 ;
14728  Matrix temp13 ;
14729  octave_value_list _out;
14730  octave_value_list *_outp=&_out;
14731  octave_value _outv;
14732 
14733  if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
14734  SWIG_fail;
14735  }
14736  {
14737  if ( _n_dims( args(0) ) > 2 )
14738  {
14739  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14740  }
14741  temp1 = args(0).matrix_value();
14742  arg1 = &temp1( 0, 0 );
14743  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14744  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14745  }
14746  ecode4 = SWIG_AsVal_double(args(1), &val4);
14747  if (!SWIG_IsOK(ecode4)) {
14748  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
14749  }
14750  arg4 = static_cast< PLFLT >(val4);
14751  ecode5 = SWIG_AsVal_double(args(2), &val5);
14752  if (!SWIG_IsOK(ecode5)) {
14753  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
14754  }
14755  arg5 = static_cast< PLFLT >(val5);
14756  ecode6 = SWIG_AsVal_double(args(3), &val6);
14757  if (!SWIG_IsOK(ecode6)) {
14758  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
14759  }
14760  arg6 = static_cast< PLFLT >(val6);
14761  ecode7 = SWIG_AsVal_double(args(4), &val7);
14762  if (!SWIG_IsOK(ecode7)) {
14763  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
14764  }
14765  arg7 = static_cast< PLFLT >(val7);
14766  ecode8 = SWIG_AsVal_double(args(5), &val8);
14767  if (!SWIG_IsOK(ecode8)) {
14768  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
14769  }
14770  arg8 = static_cast< PLFLT >(val8);
14771  ecode9 = SWIG_AsVal_double(args(6), &val9);
14772  if (!SWIG_IsOK(ecode9)) {
14773  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
14774  }
14775  arg9 = static_cast< PLFLT >(val9);
14776  ecode10 = SWIG_AsVal_double(args(7), &val10);
14777  if (!SWIG_IsOK(ecode10)) {
14778  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
14779  }
14780  arg10 = static_cast< PLFLT >(val10);
14781  ecode11 = SWIG_AsVal_double(args(8), &val11);
14782  if (!SWIG_IsOK(ecode11)) {
14783  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
14784  }
14785  arg11 = static_cast< PLFLT >(val11);
14786  {
14787  if ( _n_dims( args(9) ) > 1 )
14788  {
14789  error( "argument must be a scalar or vector" ); SWIG_fail;
14790  }
14791  if ( _dim( args(9), 0 ) != Xlen )
14792  {
14793  error( "argument vectors must be same length" ); SWIG_fail;
14794  }
14795  temp12 = args(9).matrix_value();
14796  arg12 = &temp12( 0, 0 );
14797  }
14798  {
14799  if ( _n_dims( args(10) ) > 1 )
14800  {
14801  error( "argument must be a scalar or vector" ); SWIG_fail;
14802  }
14803  if ( _dim( args(10), 0 ) != Ylen )
14804  {
14805  error( "argument vectors must be same length" ); SWIG_fail;
14806  }
14807  temp13 = args(10).matrix_value();
14808  arg13 = &temp13( 0, 0 );
14809  }
14810  my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
14811  _outv = octave_value();
14812  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14813  {
14814 
14815  }
14816  {
14817 
14818  }
14819  {
14820 
14821  }
14822  return _out;
14823 fail:
14824  {
14825 
14826  }
14827  {
14828 
14829  }
14830  {
14831 
14832  }
14833  return octave_value_list();
14834 }
14835 
14836 
14837 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
14838  PLFLT *arg1 = (PLFLT *) 0 ;
14839  PLINT arg2 ;
14840  PLINT arg3 ;
14841  PLFLT arg4 ;
14842  PLFLT arg5 ;
14843  PLFLT arg6 ;
14844  PLFLT arg7 ;
14845  PLFLT arg8 ;
14846  PLFLT arg9 ;
14847  PLFLT arg10 ;
14848  PLFLT arg11 ;
14849  PLFLT *arg12 = (PLFLT *) 0 ;
14850  PLFLT *arg13 = (PLFLT *) 0 ;
14851  Matrix temp1 ;
14852  double val4 ;
14853  int ecode4 = 0 ;
14854  double val5 ;
14855  int ecode5 = 0 ;
14856  double val6 ;
14857  int ecode6 = 0 ;
14858  double val7 ;
14859  int ecode7 = 0 ;
14860  double val8 ;
14861  int ecode8 = 0 ;
14862  double val9 ;
14863  int ecode9 = 0 ;
14864  double val10 ;
14865  int ecode10 = 0 ;
14866  double val11 ;
14867  int ecode11 = 0 ;
14868  Matrix temp12 ;
14869  Matrix temp13 ;
14870  octave_value_list _out;
14871  octave_value_list *_outp=&_out;
14872  octave_value _outv;
14873 
14874  if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
14875  SWIG_fail;
14876  }
14877  {
14878  if ( _n_dims( args(0) ) > 2 )
14879  {
14880  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14881  }
14882  temp1 = args(0).matrix_value();
14883  arg1 = &temp1( 0, 0 );
14884  arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14885  arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14886  }
14887  ecode4 = SWIG_AsVal_double(args(1), &val4);
14888  if (!SWIG_IsOK(ecode4)) {
14889  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
14890  }
14891  arg4 = static_cast< PLFLT >(val4);
14892  ecode5 = SWIG_AsVal_double(args(2), &val5);
14893  if (!SWIG_IsOK(ecode5)) {
14894  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
14895  }
14896  arg5 = static_cast< PLFLT >(val5);
14897  ecode6 = SWIG_AsVal_double(args(3), &val6);
14898  if (!SWIG_IsOK(ecode6)) {
14899  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
14900  }
14901  arg6 = static_cast< PLFLT >(val6);
14902  ecode7 = SWIG_AsVal_double(args(4), &val7);
14903  if (!SWIG_IsOK(ecode7)) {
14904  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
14905  }
14906  arg7 = static_cast< PLFLT >(val7);
14907  ecode8 = SWIG_AsVal_double(args(5), &val8);
14908  if (!SWIG_IsOK(ecode8)) {
14909  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
14910  }
14911  arg8 = static_cast< PLFLT >(val8);
14912  ecode9 = SWIG_AsVal_double(args(6), &val9);
14913  if (!SWIG_IsOK(ecode9)) {
14914  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
14915  }
14916  arg9 = static_cast< PLFLT >(val9);
14917  ecode10 = SWIG_AsVal_double(args(7), &val10);
14918  if (!SWIG_IsOK(ecode10)) {
14919  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
14920  }
14921  arg10 = static_cast< PLFLT >(val10);
14922  ecode11 = SWIG_AsVal_double(args(8), &val11);
14923  if (!SWIG_IsOK(ecode11)) {
14924  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
14925  }
14926  arg11 = static_cast< PLFLT >(val11);
14927  {
14928  if ( _n_dims( args(9) ) > 2 )
14929  {
14930  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14931  }
14932  temp12 = args(9).matrix_value();
14933  arg12 = &temp12( 0, 0 );
14934  Xlen = (PLINT) ( _dim( args(9), 0 ) );
14935  Ylen = (PLINT) ( _dim( args(9), 1 ) );
14936  }
14937  {
14938  if ( _n_dims( args(10) ) > 2 )
14939  {
14940  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14941  }
14942  temp13 = args(10).matrix_value();
14943  arg13 = &temp13( 0, 0 );
14944  Xlen = (PLINT) ( _dim( args(10), 0 ) );
14945  Ylen = (PLINT) ( _dim( args(10), 1 ) );
14946  }
14947  my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
14948  _outv = octave_value();
14949  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14950  {
14951 
14952  }
14953  {
14954 
14955  }
14956  {
14957 
14958  }
14959  return _out;
14960 fail:
14961  {
14962 
14963  }
14964  {
14965 
14966  }
14967  {
14968 
14969  }
14970  return octave_value_list();
14971 }
14972 
14973 
14975  PLFLT *arg1 = (PLFLT *) 0 ;
14976  PLFLT *arg2 = (PLFLT *) 0 ;
14977  PLINT arg3 ;
14978  PLINT arg4 ;
14979  PLFLT arg5 ;
14980  PLFLT arg6 ;
14981  PLFLT arg7 ;
14982  PLFLT arg8 ;
14983  PLINT arg9 ;
14984  PLINT arg10 ;
14985  PLINT arg11 ;
14986  PLFLT arg12 ;
14987  PLFLT arg13 ;
14988  PLINT arg14 ;
14989  PLFLT arg15 ;
14990  PLINT arg16 ;
14991  PLINT *arg17 = (PLINT *) 0 ;
14992  char **arg18 = (char **) 0 ;
14993  PLINT arg19 ;
14994  char **arg20 = (char **) 0 ;
14995  PLFLT *arg21 = (PLFLT *) 0 ;
14996  PLINT *arg22 = (PLINT *) 0 ;
14997  PLINT *arg23 = (PLINT *) 0 ;
14998  PLFLT *arg24 = (PLFLT *) 0 ;
14999  PLFLT temp1 ;
15000  int res1 = SWIG_TMPOBJ ;
15001  PLFLT temp2 ;
15002  int res2 = SWIG_TMPOBJ ;
15003  int val3 ;
15004  int ecode3 = 0 ;
15005  int val4 ;
15006  int ecode4 = 0 ;
15007  double val5 ;
15008  int ecode5 = 0 ;
15009  double val6 ;
15010  int ecode6 = 0 ;
15011  double val7 ;
15012  int ecode7 = 0 ;
15013  double val8 ;
15014  int ecode8 = 0 ;
15015  int val9 ;
15016  int ecode9 = 0 ;
15017  int val10 ;
15018  int ecode10 = 0 ;
15019  int val11 ;
15020  int ecode11 = 0 ;
15021  double val12 ;
15022  int ecode12 = 0 ;
15023  double val13 ;
15024  int ecode13 = 0 ;
15025  int val14 ;
15026  int ecode14 = 0 ;
15027  double val15 ;
15028  int ecode15 = 0 ;
15029  Matrix temp16 ;
15030  Matrix temp21 ;
15031  Matrix temp22 ;
15032  Matrix temp23 ;
15033  Matrix temp24 ;
15034  octave_value_list _out;
15035  octave_value_list *_outp=&_out;
15036  octave_value _outv;
15037 
15038  arg1 = &temp1;
15039  arg2 = &temp2;
15040  if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15041  SWIG_fail;
15042  }
15043  ecode3 = SWIG_AsVal_int(args(0), &val3);
15044  if (!SWIG_IsOK(ecode3)) {
15045  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15046  }
15047  arg3 = static_cast< PLINT >(val3);
15048  ecode4 = SWIG_AsVal_int(args(1), &val4);
15049  if (!SWIG_IsOK(ecode4)) {
15050  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15051  }
15052  arg4 = static_cast< PLINT >(val4);
15053  ecode5 = SWIG_AsVal_double(args(2), &val5);
15054  if (!SWIG_IsOK(ecode5)) {
15055  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15056  }
15057  arg5 = static_cast< PLFLT >(val5);
15058  ecode6 = SWIG_AsVal_double(args(3), &val6);
15059  if (!SWIG_IsOK(ecode6)) {
15060  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15061  }
15062  arg6 = static_cast< PLFLT >(val6);
15063  ecode7 = SWIG_AsVal_double(args(4), &val7);
15064  if (!SWIG_IsOK(ecode7)) {
15065  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15066  }
15067  arg7 = static_cast< PLFLT >(val7);
15068  ecode8 = SWIG_AsVal_double(args(5), &val8);
15069  if (!SWIG_IsOK(ecode8)) {
15070  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15071  }
15072  arg8 = static_cast< PLFLT >(val8);
15073  ecode9 = SWIG_AsVal_int(args(6), &val9);
15074  if (!SWIG_IsOK(ecode9)) {
15075  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15076  }
15077  arg9 = static_cast< PLINT >(val9);
15078  ecode10 = SWIG_AsVal_int(args(7), &val10);
15079  if (!SWIG_IsOK(ecode10)) {
15080  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15081  }
15082  arg10 = static_cast< PLINT >(val10);
15083  ecode11 = SWIG_AsVal_int(args(8), &val11);
15084  if (!SWIG_IsOK(ecode11)) {
15085  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15086  }
15087  arg11 = static_cast< PLINT >(val11);
15088  ecode12 = SWIG_AsVal_double(args(9), &val12);
15089  if (!SWIG_IsOK(ecode12)) {
15090  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15091  }
15092  arg12 = static_cast< PLFLT >(val12);
15093  ecode13 = SWIG_AsVal_double(args(10), &val13);
15094  if (!SWIG_IsOK(ecode13)) {
15095  SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15096  }
15097  arg13 = static_cast< PLFLT >(val13);
15098  ecode14 = SWIG_AsVal_int(args(11), &val14);
15099  if (!SWIG_IsOK(ecode14)) {
15100  SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15101  }
15102  arg14 = static_cast< PLINT >(val14);
15103  ecode15 = SWIG_AsVal_double(args(12), &val15);
15104  if (!SWIG_IsOK(ecode15)) {
15105  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15106  }
15107  arg15 = static_cast< PLFLT >(val15);
15108  {
15109  if ( _n_dims( args(13) ) > 1 )
15110  {
15111  error( "argument must be a scalar or vector" ); SWIG_fail;
15112  }
15113  arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15114  arg17 = new PLINT[Alen];
15115  temp16 = args(13).matrix_value();
15116  _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15117  }
15118  {
15119  charMatrix temp_matrix;
15120  Cell temp_cell;
15121  char *tmp_cstring;
15122  std::string str;
15123  size_t max_length = 0, non_blank_length;
15124  int i, ifcell;
15125  if ( _n_dims( args(14) ) > 2 )
15126  {
15127  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15128  }
15129 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15130  if ( !args(14).isempty() )
15131 #else
15132  if ( !args(14).is_empty() )
15133 #endif
15134  {
15135  if ( _dim( args(14), 0 ) != Alen )
15136  {
15137  error( "first dimension must be same length as previous vector" ); SWIG_fail;
15138  }
15139  arg18 = new char*[Alen];
15140 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15141  ifcell = args(14).iscell();
15142 #else
15143  ifcell = args(14).is_cell();
15144 #endif
15145  if ( ifcell )
15146  {
15147  temp_cell = args(14).cell_value();
15148  }
15149  else
15150  {
15151  temp_matrix = args(14).char_matrix_value();
15152  // Allow one extra space for null termination.
15153  max_length = _dim( args(14), 1 ) + 1;
15154  }
15155 
15156  for ( i = 0; i < Alen; i++ )
15157  {
15158  // Must copy string to "permanent" location because the string
15159  // location corresponding to tmp_cstring gets
15160  // overwritten for each iteration of loop.
15161  if ( ifcell )
15162  {
15163  if ( temp_cell.elem( i ).is_string() )
15164  {
15165  str = temp_cell.elem( i ).string_value();
15166  // leave room for null termination.
15167  max_length = str.size() + 1;
15168  tmp_cstring = (char *) str.c_str();
15169  }
15170  else
15171  {
15172  // Use null string if user attempts to pass a cell array
15173  // with a non-string element (likely an empty element
15174  // since that should be allowed by the PLplot interface
15175  // if that element is going to be unused).
15176  // leave room for null termination.
15177  max_length = 1;
15178  tmp_cstring = (char *) "";
15179  }
15180  }
15181  else
15182  {
15183  str = temp_matrix.row_as_string( i );
15184  tmp_cstring = (char *) str.c_str();
15185  }
15186  arg18[i] = new char[max_length];
15187  strncpy( arg18[i], tmp_cstring, max_length - 1 );
15188  arg18[i][max_length - 1] = '\0';
15189  // All the trailing blank crapola should not be needed for
15190  // string cell arrays.
15191  if ( !ifcell )
15192  {
15193  // remove trailing-blank padding that is used by the
15194  // charMatrix class to insure all strings in a given
15195  // charMatrix instance have the same length.
15196  // This transformation also removes legitimate trailing
15197  // blanks but there is nothing we can do about that
15198  // for the charMatrix class.
15199 
15200  // Look for trailing nulls first (just in case, although that
15201  // shouldn't happen if charMatrix implemented as documented)
15202  // before looking for trailing blanks.
15203  non_blank_length = max_length - 2;
15204  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15205  {
15206  non_blank_length--;
15207  }
15208  while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15209  {
15210  non_blank_length--;
15211  }
15212  arg18[i][non_blank_length + 1] = '\0';
15213  }
15214  }
15215  }
15216  else
15217  {
15218  arg18 = NULL;
15219  }
15220  }
15221  {
15222  charMatrix temp_matrix;
15223  Cell temp_cell;
15224  char *tmp_cstring;
15225  std::string str;
15226  size_t max_length = 0, non_blank_length;
15227  int i, ifcell;
15228  if ( _n_dims( args(15) ) > 2 )
15229  {
15230  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15231  }
15232 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15233  if ( !args(15).isempty() )
15234 #else
15235  if ( !args(15).is_empty() )
15236 #endif
15237  {
15238  Alen = _dim( args(15), 0 );
15239  arg19 = Alen;
15240  arg20 = new char*[Alen];
15241 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15242  ifcell = args(15).iscell();
15243 #else
15244  ifcell = args(15).is_cell();
15245 #endif
15246  if ( ifcell )
15247  {
15248  temp_cell = args(15).cell_value();
15249  }
15250  else
15251  {
15252  temp_matrix = args(15).char_matrix_value();
15253  // Allow one extra space for null termination.
15254  max_length = _dim( args(15), 1 ) + 1;
15255  }
15256 
15257  for ( i = 0; i < Alen; i++ )
15258  {
15259  // Must copy string to "permanent" location because the string
15260  // location corresponding to tmp_cstring gets
15261  // overwritten for each iteration of loop.
15262  if ( ifcell )
15263  {
15264  if ( temp_cell.elem( i ).is_string() )
15265  {
15266  str = temp_cell.elem( i ).string_value();
15267  // leave room for null termination.
15268  max_length = str.size() + 1;
15269  tmp_cstring = (char *) str.c_str();
15270  }
15271  else
15272  {
15273  // Use null string if user attempts to pass a cell array
15274  // with a non-string element (likely an empty element
15275  // since that should be allowed by the PLplot interface
15276  // if that element is going to be unused).
15277  // leave room for null termination.
15278  max_length = 1;
15279  tmp_cstring = (char *) "";
15280  }
15281  }
15282  else
15283  {
15284  str = temp_matrix.row_as_string( i );
15285  tmp_cstring = (char *) str.c_str();
15286  }
15287  arg20[i] = new char[max_length];
15288  strncpy( arg20[i], tmp_cstring, max_length - 1 );
15289  arg20[i][max_length - 1] = '\0';
15290  // All the trailing blank crapola should not be needed for
15291  // string cell arrays.
15292  if ( !ifcell )
15293  {
15294  // remove trailing-blank padding that is used by the
15295  // charMatrix class to insure all strings in a given
15296  // charMatrix instance have the same length.
15297  // This transformation also removes legitimate trailing
15298  // blanks but there is nothing we can do about that
15299  // for the charMatrix class.
15300 
15301  // Look for trailing nulls first (just in case, although that
15302  // shouldn't happen if charMatrix implemented as documented)
15303  // before looking for trailing blanks.
15304  non_blank_length = max_length - 2;
15305  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
15306  {
15307  non_blank_length--;
15308  }
15309  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
15310  {
15311  non_blank_length--;
15312  }
15313  arg20[i][non_blank_length + 1] = '\0';
15314  }
15315  }
15316  }
15317  else
15318  {
15319  arg19 = 0;
15320  arg20 = NULL;
15321  }
15322  }
15323  {
15324  if ( _n_dims( args(16) ) > 1 )
15325  {
15326  error( "argument must be a scalar or vector" ); SWIG_fail;
15327  }
15328  if ( _dim( args(16), 0 ) != Alen )
15329  {
15330  error( "argument vectors must be same length" ); SWIG_fail;
15331  }
15332  temp21 = args(16).matrix_value();
15333  arg21 = &temp21( 0, 0 );
15334  }
15335  {
15336  if ( _n_dims( args(17) ) > 1 )
15337  {
15338  error( "argument must be a scalar or vector" ); SWIG_fail;
15339  }
15340  if ( _dim( args(17), 0 ) != Alen )
15341  {
15342  error( "argument vectors must be same length" ); SWIG_fail;
15343  }
15344  temp22 = args(17).matrix_value();
15345  arg22 = new PLINT[Alen];
15346  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
15347  }
15348  {
15349  int i;
15350  if ( _n_dims( args(18) ) > 1 )
15351  {
15352  error( "argument must be a scalar or vector" ); SWIG_fail;
15353  }
15354  if ( _dim( args(18), 0 ) != Alen )
15355  {
15356  error( "argument vectors must be same length" ); SWIG_fail;
15357  }
15358  Xlen = Alen;
15359  temp23 = args(18).matrix_value();
15360  arg23 = new PLINT[Alen];
15361  _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
15362  Ylen = -1;
15363  for ( i = 0; i < Xlen; i++ )
15364  if ( arg23[i] > Ylen )
15365  Ylen = arg23[i];
15366  }
15367  {
15368  if ( _n_dims( args(19) ) > 2 )
15369  {
15370  error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15371  }
15372  if ( _dim( args(19), 0 ) != Xlen )
15373  {
15374  error( "argument matrix must have same X length as X vector" ); SWIG_fail;
15375  }
15376  if ( _dim( args(19), 1 ) != Ylen )
15377  {
15378  error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
15379  }
15380  temp24 = args(19).matrix_value();
15381  arg24 = &temp24( 0, 0 );
15382  }
15383  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);
15384  _outv = octave_value();
15385  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15386  if (SWIG_IsTmpObj(res1)) {
15387  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15388  } else {
15389  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15390  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15391  }
15392  if (SWIG_IsTmpObj(res2)) {
15393  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15394  } else {
15395  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15396  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15397  }
15398  {
15399  delete [] arg17;
15400  }
15401  {
15402  int i;
15403  if ( arg18 != NULL )
15404  {
15405  for ( i = 0; i < Alen; i++ )
15406  {
15407  delete[] arg18[i];
15408  }
15409  delete[] arg18;
15410  }
15411  }
15412  {
15413  int i;
15414  if ( arg20 != NULL )
15415  {
15416  for ( i = 0; i < Alen; i++ )
15417  {
15418  delete[] arg20[i];
15419  }
15420  delete[] arg20;
15421  }
15422  }
15423  {
15424 
15425  }
15426  {
15427  delete [] arg22;
15428  }
15429  {
15430  delete [] arg23;
15431  }
15432  {
15433 
15434  }
15435  return _out;
15436 fail:
15437  {
15438  delete [] arg17;
15439  }
15440  {
15441  int i;
15442  if ( arg18 != NULL )
15443  {
15444  for ( i = 0; i < Alen; i++ )
15445  {
15446  delete[] arg18[i];
15447  }
15448  delete[] arg18;
15449  }
15450  }
15451  {
15452  int i;
15453  if ( arg20 != NULL )
15454  {
15455  for ( i = 0; i < Alen; i++ )
15456  {
15457  delete[] arg20[i];
15458  }
15459  delete[] arg20;
15460  }
15461  }
15462  {
15463 
15464  }
15465  {
15466  delete [] arg22;
15467  }
15468  {
15469  delete [] arg23;
15470  }
15471  {
15472 
15473  }
15474  return octave_value_list();
15475 }
15476 
15477 
15478 SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
15479  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15480  int arg2 ;
15481  void *argp1 = 0 ;
15482  int res1 = 0 ;
15483  int val2 ;
15484  int ecode2 = 0 ;
15485  octave_value_list _out;
15486  octave_value_list *_outp=&_out;
15487  octave_value _outv;
15488 
15489  if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
15490  SWIG_fail;
15491  }
15492  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15493  if (!SWIG_IsOK(res1)) {
15494  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15495  }
15496  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15497  ecode2 = SWIG_AsVal_int(args(1), &val2);
15498  if (!SWIG_IsOK(ecode2)) {
15499  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
15500  }
15501  arg2 = static_cast< int >(val2);
15502  if (arg1) (arg1)->type = arg2;
15503  _outv = octave_value();
15504  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15505  return _out;
15506 fail:
15507  return octave_value_list();
15508 }
15509 
15510 
15511 SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
15512  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15513  void *argp1 = 0 ;
15514  int res1 = 0 ;
15515  octave_value_list _out;
15516  octave_value_list *_outp=&_out;
15517  octave_value _outv;
15518  int result;
15519 
15520  if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
15521  SWIG_fail;
15522  }
15523  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15524  if (!SWIG_IsOK(res1)) {
15525  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15526  }
15527  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15528  result = (int) ((arg1)->type);
15529  _outv = SWIG_From_int(static_cast< int >(result));
15530  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15531  return _out;
15532 fail:
15533  return octave_value_list();
15534 }
15535 
15536 
15537 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
15538  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15539  unsigned int arg2 ;
15540  void *argp1 = 0 ;
15541  int res1 = 0 ;
15542  unsigned int val2 ;
15543  int ecode2 = 0 ;
15544  octave_value_list _out;
15545  octave_value_list *_outp=&_out;
15546  octave_value _outv;
15547 
15548  if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
15549  SWIG_fail;
15550  }
15551  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15552  if (!SWIG_IsOK(res1)) {
15553  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15554  }
15555  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15556  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15557  if (!SWIG_IsOK(ecode2)) {
15558  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
15559  }
15560  arg2 = static_cast< unsigned int >(val2);
15561  if (arg1) (arg1)->state = arg2;
15562  _outv = octave_value();
15563  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15564  return _out;
15565 fail:
15566  return octave_value_list();
15567 }
15568 
15569 
15570 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
15571  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15572  void *argp1 = 0 ;
15573  int res1 = 0 ;
15574  octave_value_list _out;
15575  octave_value_list *_outp=&_out;
15576  octave_value _outv;
15577  unsigned int result;
15578 
15579  if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
15580  SWIG_fail;
15581  }
15582  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15583  if (!SWIG_IsOK(res1)) {
15584  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15585  }
15586  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15587  result = (unsigned int) ((arg1)->state);
15588  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15589  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15590  return _out;
15591 fail:
15592  return octave_value_list();
15593 }
15594 
15595 
15596 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
15597  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15598  unsigned int arg2 ;
15599  void *argp1 = 0 ;
15600  int res1 = 0 ;
15601  unsigned int val2 ;
15602  int ecode2 = 0 ;
15603  octave_value_list _out;
15604  octave_value_list *_outp=&_out;
15605  octave_value _outv;
15606 
15607  if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
15608  SWIG_fail;
15609  }
15610  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15611  if (!SWIG_IsOK(res1)) {
15612  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15613  }
15614  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15615  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15616  if (!SWIG_IsOK(ecode2)) {
15617  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
15618  }
15619  arg2 = static_cast< unsigned int >(val2);
15620  if (arg1) (arg1)->keysym = arg2;
15621  _outv = octave_value();
15622  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15623  return _out;
15624 fail:
15625  return octave_value_list();
15626 }
15627 
15628 
15629 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
15630  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15631  void *argp1 = 0 ;
15632  int res1 = 0 ;
15633  octave_value_list _out;
15634  octave_value_list *_outp=&_out;
15635  octave_value _outv;
15636  unsigned int result;
15637 
15638  if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
15639  SWIG_fail;
15640  }
15641  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15642  if (!SWIG_IsOK(res1)) {
15643  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15644  }
15645  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15646  result = (unsigned int) ((arg1)->keysym);
15647  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15648  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15649  return _out;
15650 fail:
15651  return octave_value_list();
15652 }
15653 
15654 
15655 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
15656  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15657  unsigned int arg2 ;
15658  void *argp1 = 0 ;
15659  int res1 = 0 ;
15660  unsigned int val2 ;
15661  int ecode2 = 0 ;
15662  octave_value_list _out;
15663  octave_value_list *_outp=&_out;
15664  octave_value _outv;
15665 
15666  if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
15667  SWIG_fail;
15668  }
15669  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15670  if (!SWIG_IsOK(res1)) {
15671  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15672  }
15673  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15674  ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15675  if (!SWIG_IsOK(ecode2)) {
15676  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
15677  }
15678  arg2 = static_cast< unsigned int >(val2);
15679  if (arg1) (arg1)->button = arg2;
15680  _outv = octave_value();
15681  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15682  return _out;
15683 fail:
15684  return octave_value_list();
15685 }
15686 
15687 
15688 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
15689  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15690  void *argp1 = 0 ;
15691  int res1 = 0 ;
15692  octave_value_list _out;
15693  octave_value_list *_outp=&_out;
15694  octave_value _outv;
15695  unsigned int result;
15696 
15697  if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
15698  SWIG_fail;
15699  }
15700  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15701  if (!SWIG_IsOK(res1)) {
15702  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15703  }
15704  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15705  result = (unsigned int) ((arg1)->button);
15706  _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15707  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15708  return _out;
15709 fail:
15710  return octave_value_list();
15711 }
15712 
15713 
15714 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
15715  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15716  PLINT arg2 ;
15717  void *argp1 = 0 ;
15718  int res1 = 0 ;
15719  int val2 ;
15720  int ecode2 = 0 ;
15721  octave_value_list _out;
15722  octave_value_list *_outp=&_out;
15723  octave_value _outv;
15724 
15725  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
15726  SWIG_fail;
15727  }
15728  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15729  if (!SWIG_IsOK(res1)) {
15730  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15731  }
15732  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15733  ecode2 = SWIG_AsVal_int(args(1), &val2);
15734  if (!SWIG_IsOK(ecode2)) {
15735  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
15736  }
15737  arg2 = static_cast< PLINT >(val2);
15738  if (arg1) (arg1)->subwindow = arg2;
15739  _outv = octave_value();
15740  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15741  return _out;
15742 fail:
15743  return octave_value_list();
15744 }
15745 
15746 
15747 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
15748  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15749  void *argp1 = 0 ;
15750  int res1 = 0 ;
15751  octave_value_list _out;
15752  octave_value_list *_outp=&_out;
15753  octave_value _outv;
15754  PLINT result;
15755 
15756  if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
15757  SWIG_fail;
15758  }
15759  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15760  if (!SWIG_IsOK(res1)) {
15761  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15762  }
15763  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15764  result = (PLINT) ((arg1)->subwindow);
15765  _outv = SWIG_From_int(static_cast< int >(result));
15766  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15767  return _out;
15768 fail:
15769  return octave_value_list();
15770 }
15771 
15772 
15773 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
15774  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15775  char *arg2 ;
15776  void *argp1 = 0 ;
15777  int res1 = 0 ;
15778  char temp2[16] ;
15779  int res2 ;
15780  octave_value_list _out;
15781  octave_value_list *_outp=&_out;
15782  octave_value _outv;
15783 
15784  if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
15785  SWIG_fail;
15786  }
15787  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15788  if (!SWIG_IsOK(res1)) {
15789  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15790  }
15791  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15792  res2 = SWIG_AsCharArray(args(1), temp2, 16);
15793  if (!SWIG_IsOK(res2)) {
15794  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
15795  }
15796  arg2 = reinterpret_cast< char * >(temp2);
15797  if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
15798  else memset(arg1->string,0,16*sizeof(char));
15799  _outv = octave_value();
15800  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15801  return _out;
15802 fail:
15803  return octave_value_list();
15804 }
15805 
15806 
15807 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
15808  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15809  void *argp1 = 0 ;
15810  int res1 = 0 ;
15811  octave_value_list _out;
15812  octave_value_list *_outp=&_out;
15813  octave_value _outv;
15814  char *result = 0 ;
15815 
15816  if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
15817  SWIG_fail;
15818  }
15819  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15820  if (!SWIG_IsOK(res1)) {
15821  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15822  }
15823  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15824  result = (char *)(char *) ((arg1)->string);
15825  {
15826  size_t size = SWIG_strnlen(result, 16);
15827 
15828 
15829 
15830  _outv = SWIG_FromCharPtrAndSize(result, size);
15831  }
15832  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15833  return _out;
15834 fail:
15835  return octave_value_list();
15836 }
15837 
15838 
15839 SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
15840  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15841  int arg2 ;
15842  void *argp1 = 0 ;
15843  int res1 = 0 ;
15844  int val2 ;
15845  int ecode2 = 0 ;
15846  octave_value_list _out;
15847  octave_value_list *_outp=&_out;
15848  octave_value _outv;
15849 
15850  if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
15851  SWIG_fail;
15852  }
15853  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15854  if (!SWIG_IsOK(res1)) {
15855  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15856  }
15857  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15858  ecode2 = SWIG_AsVal_int(args(1), &val2);
15859  if (!SWIG_IsOK(ecode2)) {
15860  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
15861  }
15862  arg2 = static_cast< int >(val2);
15863  if (arg1) (arg1)->pX = arg2;
15864  _outv = octave_value();
15865  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15866  return _out;
15867 fail:
15868  return octave_value_list();
15869 }
15870 
15871 
15872 SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
15873  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15874  void *argp1 = 0 ;
15875  int res1 = 0 ;
15876  octave_value_list _out;
15877  octave_value_list *_outp=&_out;
15878  octave_value _outv;
15879  int result;
15880 
15881  if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
15882  SWIG_fail;
15883  }
15884  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15885  if (!SWIG_IsOK(res1)) {
15886  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15887  }
15888  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15889  result = (int) ((arg1)->pX);
15890  _outv = SWIG_From_int(static_cast< int >(result));
15891  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15892  return _out;
15893 fail:
15894  return octave_value_list();
15895 }
15896 
15897 
15898 SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
15899  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15900  int arg2 ;
15901  void *argp1 = 0 ;
15902  int res1 = 0 ;
15903  int val2 ;
15904  int ecode2 = 0 ;
15905  octave_value_list _out;
15906  octave_value_list *_outp=&_out;
15907  octave_value _outv;
15908 
15909  if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
15910  SWIG_fail;
15911  }
15912  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15913  if (!SWIG_IsOK(res1)) {
15914  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15915  }
15916  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15917  ecode2 = SWIG_AsVal_int(args(1), &val2);
15918  if (!SWIG_IsOK(ecode2)) {
15919  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
15920  }
15921  arg2 = static_cast< int >(val2);
15922  if (arg1) (arg1)->pY = arg2;
15923  _outv = octave_value();
15924  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15925  return _out;
15926 fail:
15927  return octave_value_list();
15928 }
15929 
15930 
15931 SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
15932  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15933  void *argp1 = 0 ;
15934  int res1 = 0 ;
15935  octave_value_list _out;
15936  octave_value_list *_outp=&_out;
15937  octave_value _outv;
15938  int result;
15939 
15940  if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
15941  SWIG_fail;
15942  }
15943  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15944  if (!SWIG_IsOK(res1)) {
15945  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15946  }
15947  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15948  result = (int) ((arg1)->pY);
15949  _outv = SWIG_From_int(static_cast< int >(result));
15950  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15951  return _out;
15952 fail:
15953  return octave_value_list();
15954 }
15955 
15956 
15957 SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
15958  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15959  PLFLT arg2 ;
15960  void *argp1 = 0 ;
15961  int res1 = 0 ;
15962  double val2 ;
15963  int ecode2 = 0 ;
15964  octave_value_list _out;
15965  octave_value_list *_outp=&_out;
15966  octave_value _outv;
15967 
15968  if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
15969  SWIG_fail;
15970  }
15971  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15972  if (!SWIG_IsOK(res1)) {
15973  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15974  }
15975  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15976  ecode2 = SWIG_AsVal_double(args(1), &val2);
15977  if (!SWIG_IsOK(ecode2)) {
15978  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
15979  }
15980  arg2 = static_cast< PLFLT >(val2);
15981  if (arg1) (arg1)->dX = arg2;
15982  _outv = octave_value();
15983  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15984  return _out;
15985 fail:
15986  return octave_value_list();
15987 }
15988 
15989 
15990 SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
15991  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15992  void *argp1 = 0 ;
15993  int res1 = 0 ;
15994  octave_value_list _out;
15995  octave_value_list *_outp=&_out;
15996  octave_value _outv;
15997  PLFLT result;
15998 
15999  if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
16000  SWIG_fail;
16001  }
16002  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16003  if (!SWIG_IsOK(res1)) {
16004  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16005  }
16006  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16007  result = (PLFLT) ((arg1)->dX);
16008  _outv = SWIG_From_double(static_cast< double >(result));
16009  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16010  return _out;
16011 fail:
16012  return octave_value_list();
16013 }
16014 
16015 
16016 SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16017  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16018  PLFLT arg2 ;
16019  void *argp1 = 0 ;
16020  int res1 = 0 ;
16021  double val2 ;
16022  int ecode2 = 0 ;
16023  octave_value_list _out;
16024  octave_value_list *_outp=&_out;
16025  octave_value _outv;
16026 
16027  if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16028  SWIG_fail;
16029  }
16030  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16031  if (!SWIG_IsOK(res1)) {
16032  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16033  }
16034  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16035  ecode2 = SWIG_AsVal_double(args(1), &val2);
16036  if (!SWIG_IsOK(ecode2)) {
16037  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16038  }
16039  arg2 = static_cast< PLFLT >(val2);
16040  if (arg1) (arg1)->dY = arg2;
16041  _outv = octave_value();
16042  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16043  return _out;
16044 fail:
16045  return octave_value_list();
16046 }
16047 
16048 
16049 SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16050  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16051  void *argp1 = 0 ;
16052  int res1 = 0 ;
16053  octave_value_list _out;
16054  octave_value_list *_outp=&_out;
16055  octave_value _outv;
16056  PLFLT result;
16057 
16058  if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16059  SWIG_fail;
16060  }
16061  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16062  if (!SWIG_IsOK(res1)) {
16063  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16064  }
16065  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16066  result = (PLFLT) ((arg1)->dY);
16067  _outv = SWIG_From_double(static_cast< double >(result));
16068  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16069  return _out;
16070 fail:
16071  return octave_value_list();
16072 }
16073 
16074 
16075 SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16076  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16077  PLFLT arg2 ;
16078  void *argp1 = 0 ;
16079  int res1 = 0 ;
16080  double val2 ;
16081  int ecode2 = 0 ;
16082  octave_value_list _out;
16083  octave_value_list *_outp=&_out;
16084  octave_value _outv;
16085 
16086  if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16087  SWIG_fail;
16088  }
16089  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16090  if (!SWIG_IsOK(res1)) {
16091  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16092  }
16093  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16094  ecode2 = SWIG_AsVal_double(args(1), &val2);
16095  if (!SWIG_IsOK(ecode2)) {
16096  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16097  }
16098  arg2 = static_cast< PLFLT >(val2);
16099  if (arg1) (arg1)->wX = arg2;
16100  _outv = octave_value();
16101  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16102  return _out;
16103 fail:
16104  return octave_value_list();
16105 }
16106 
16107 
16108 SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16109  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16110  void *argp1 = 0 ;
16111  int res1 = 0 ;
16112  octave_value_list _out;
16113  octave_value_list *_outp=&_out;
16114  octave_value _outv;
16115  PLFLT result;
16116 
16117  if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16118  SWIG_fail;
16119  }
16120  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16121  if (!SWIG_IsOK(res1)) {
16122  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16123  }
16124  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16125  result = (PLFLT) ((arg1)->wX);
16126  _outv = SWIG_From_double(static_cast< double >(result));
16127  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16128  return _out;
16129 fail:
16130  return octave_value_list();
16131 }
16132 
16133 
16134 SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
16135  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16136  PLFLT arg2 ;
16137  void *argp1 = 0 ;
16138  int res1 = 0 ;
16139  double val2 ;
16140  int ecode2 = 0 ;
16141  octave_value_list _out;
16142  octave_value_list *_outp=&_out;
16143  octave_value _outv;
16144 
16145  if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
16146  SWIG_fail;
16147  }
16148  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16149  if (!SWIG_IsOK(res1)) {
16150  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16151  }
16152  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16153  ecode2 = SWIG_AsVal_double(args(1), &val2);
16154  if (!SWIG_IsOK(ecode2)) {
16155  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
16156  }
16157  arg2 = static_cast< PLFLT >(val2);
16158  if (arg1) (arg1)->wY = arg2;
16159  _outv = octave_value();
16160  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16161  return _out;
16162 fail:
16163  return octave_value_list();
16164 }
16165 
16166 
16167 SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
16168  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16169  void *argp1 = 0 ;
16170  int res1 = 0 ;
16171  octave_value_list _out;
16172  octave_value_list *_outp=&_out;
16173  octave_value _outv;
16174  PLFLT result;
16175 
16176  if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
16177  SWIG_fail;
16178  }
16179  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16180  if (!SWIG_IsOK(res1)) {
16181  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16182  }
16183  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16184  result = (PLFLT) ((arg1)->wY);
16185  _outv = SWIG_From_double(static_cast< double >(result));
16186  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16187  return _out;
16188 fail:
16189  return octave_value_list();
16190 }
16191 
16192 
16193 SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
16194  octave_value_list _out;
16195  octave_value_list *_outp=&_out;
16196  octave_value _outv;
16197  PLGraphicsIn *result = 0 ;
16198 
16199  if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
16200  SWIG_fail;
16201  }
16202  result = (PLGraphicsIn *)new PLGraphicsIn();
16204  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16205  return _out;
16206 fail:
16207  return octave_value_list();
16208 }
16209 
16210 
16211 SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
16212  PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16213  void *argp1 = 0 ;
16214  int res1 = 0 ;
16215  octave_value_list _out;
16216  octave_value_list *_outp=&_out;
16217  octave_value _outv;
16218 
16219  if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
16220  SWIG_fail;
16221  }
16222  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
16223  if (!SWIG_IsOK(res1)) {
16224  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16225  }
16226  arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16227  delete arg1;
16228  _outv = octave_value();
16229  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16230  return _out;
16231 fail:
16232  return octave_value_list();
16233 }
16234 
16235 
16249 {0,0,0,0,0,0}
16250 };
16251 static const char *swig_PLGraphicsIn_base_names[] = {0};
16254 
16256  PLINT arg1 ;
16257  PLINT arg2 ;
16258  int val1 ;
16259  int ecode1 = 0 ;
16260  int val2 ;
16261  int ecode2 = 0 ;
16262  octave_value_list _out;
16263  octave_value_list *_outp=&_out;
16264  octave_value _outv;
16265 
16266  if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
16267  SWIG_fail;
16268  }
16269  ecode1 = SWIG_AsVal_int(args(0), &val1);
16270  if (!SWIG_IsOK(ecode1)) {
16271  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
16272  }
16273  arg1 = static_cast< PLINT >(val1);
16274  ecode2 = SWIG_AsVal_int(args(1), &val2);
16275  if (!SWIG_IsOK(ecode2)) {
16276  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
16277  }
16278  arg2 = static_cast< PLINT >(val2);
16279  pl_setcontlabelformat(arg1,arg2);
16280  _outv = octave_value();
16281  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16282  return _out;
16283 fail:
16284  return octave_value_list();
16285 }
16286 
16287 
16289  PLFLT arg1 ;
16290  PLFLT arg2 ;
16291  PLFLT arg3 ;
16292  PLINT arg4 ;
16293  double val1 ;
16294  int ecode1 = 0 ;
16295  double val2 ;
16296  int ecode2 = 0 ;
16297  double val3 ;
16298  int ecode3 = 0 ;
16299  int val4 ;
16300  int ecode4 = 0 ;
16301  octave_value_list _out;
16302  octave_value_list *_outp=&_out;
16303  octave_value _outv;
16304 
16305  if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
16306  SWIG_fail;
16307  }
16308  ecode1 = SWIG_AsVal_double(args(0), &val1);
16309  if (!SWIG_IsOK(ecode1)) {
16310  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
16311  }
16312  arg1 = static_cast< PLFLT >(val1);
16313  ecode2 = SWIG_AsVal_double(args(1), &val2);
16314  if (!SWIG_IsOK(ecode2)) {
16315  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
16316  }
16317  arg2 = static_cast< PLFLT >(val2);
16318  ecode3 = SWIG_AsVal_double(args(2), &val3);
16319  if (!SWIG_IsOK(ecode3)) {
16320  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
16321  }
16322  arg3 = static_cast< PLFLT >(val3);
16323  ecode4 = SWIG_AsVal_int(args(3), &val4);
16324  if (!SWIG_IsOK(ecode4)) {
16325  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
16326  }
16327  arg4 = static_cast< PLINT >(val4);
16328  pl_setcontlabelparam(arg1,arg2,arg3,arg4);
16329  _outv = octave_value();
16330  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16331  return _out;
16332 fail:
16333  return octave_value_list();
16334 }
16335 
16336 
16338  PLINT arg1 ;
16339  int val1 ;
16340  int ecode1 = 0 ;
16341  octave_value_list _out;
16342  octave_value_list *_outp=&_out;
16343  octave_value _outv;
16344 
16345  if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
16346  SWIG_fail;
16347  }
16348  ecode1 = SWIG_AsVal_int(args(0), &val1);
16349  if (!SWIG_IsOK(ecode1)) {
16350  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
16351  }
16352  arg1 = static_cast< PLINT >(val1);
16353  pladv(arg1);
16354  _outv = octave_value();
16355  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16356  return _out;
16357 fail:
16358  return octave_value_list();
16359 }
16360 
16361 
16363  PLFLT arg1 ;
16364  PLFLT arg2 ;
16365  PLFLT arg3 ;
16366  PLFLT arg4 ;
16367  PLFLT arg5 ;
16368  PLFLT arg6 ;
16369  PLFLT arg7 ;
16370  PLBOOL arg8 ;
16371  double val1 ;
16372  int ecode1 = 0 ;
16373  double val2 ;
16374  int ecode2 = 0 ;
16375  double val3 ;
16376  int ecode3 = 0 ;
16377  double val4 ;
16378  int ecode4 = 0 ;
16379  double val5 ;
16380  int ecode5 = 0 ;
16381  double val6 ;
16382  int ecode6 = 0 ;
16383  double val7 ;
16384  int ecode7 = 0 ;
16385  int val8 ;
16386  int ecode8 = 0 ;
16387  octave_value_list _out;
16388  octave_value_list *_outp=&_out;
16389  octave_value _outv;
16390 
16391  if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
16392  SWIG_fail;
16393  }
16394  ecode1 = SWIG_AsVal_double(args(0), &val1);
16395  if (!SWIG_IsOK(ecode1)) {
16396  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
16397  }
16398  arg1 = static_cast< PLFLT >(val1);
16399  ecode2 = SWIG_AsVal_double(args(1), &val2);
16400  if (!SWIG_IsOK(ecode2)) {
16401  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
16402  }
16403  arg2 = static_cast< PLFLT >(val2);
16404  ecode3 = SWIG_AsVal_double(args(2), &val3);
16405  if (!SWIG_IsOK(ecode3)) {
16406  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
16407  }
16408  arg3 = static_cast< PLFLT >(val3);
16409  ecode4 = SWIG_AsVal_double(args(3), &val4);
16410  if (!SWIG_IsOK(ecode4)) {
16411  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
16412  }
16413  arg4 = static_cast< PLFLT >(val4);
16414  ecode5 = SWIG_AsVal_double(args(4), &val5);
16415  if (!SWIG_IsOK(ecode5)) {
16416  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
16417  }
16418  arg5 = static_cast< PLFLT >(val5);
16419  ecode6 = SWIG_AsVal_double(args(5), &val6);
16420  if (!SWIG_IsOK(ecode6)) {
16421  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
16422  }
16423  arg6 = static_cast< PLFLT >(val6);
16424  ecode7 = SWIG_AsVal_double(args(6), &val7);
16425  if (!SWIG_IsOK(ecode7)) {
16426  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
16427  }
16428  arg7 = static_cast< PLFLT >(val7);
16429  ecode8 = SWIG_AsVal_int(args(7), &val8);
16430  if (!SWIG_IsOK(ecode8)) {
16431  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
16432  }
16433  arg8 = static_cast< PLBOOL >(val8);
16434  plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16435  _outv = octave_value();
16436  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16437  return _out;
16438 fail:
16439  return octave_value_list();
16440 }
16441 
16442 
16444  PLFLT arg1 ;
16445  PLFLT arg2 ;
16446  char *arg3 = (char *) 0 ;
16447  PLFLT arg4 ;
16448  PLINT arg5 ;
16449  char *arg6 = (char *) 0 ;
16450  PLFLT arg7 ;
16451  PLINT arg8 ;
16452  double val1 ;
16453  int ecode1 = 0 ;
16454  double val2 ;
16455  int ecode2 = 0 ;
16456  int res3 ;
16457  char *buf3 = 0 ;
16458  int alloc3 = 0 ;
16459  double val4 ;
16460  int ecode4 = 0 ;
16461  int val5 ;
16462  int ecode5 = 0 ;
16463  int res6 ;
16464  char *buf6 = 0 ;
16465  int alloc6 = 0 ;
16466  double val7 ;
16467  int ecode7 = 0 ;
16468  int val8 ;
16469  int ecode8 = 0 ;
16470  octave_value_list _out;
16471  octave_value_list *_outp=&_out;
16472  octave_value _outv;
16473 
16474  if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
16475  SWIG_fail;
16476  }
16477  ecode1 = SWIG_AsVal_double(args(0), &val1);
16478  if (!SWIG_IsOK(ecode1)) {
16479  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
16480  }
16481  arg1 = static_cast< PLFLT >(val1);
16482  ecode2 = SWIG_AsVal_double(args(1), &val2);
16483  if (!SWIG_IsOK(ecode2)) {
16484  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
16485  }
16486  arg2 = static_cast< PLFLT >(val2);
16487  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
16488  if (!SWIG_IsOK(res3)) {
16489  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
16490  }
16491  arg3 = reinterpret_cast< char * >(buf3);
16492  ecode4 = SWIG_AsVal_double(args(3), &val4);
16493  if (!SWIG_IsOK(ecode4)) {
16494  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
16495  }
16496  arg4 = static_cast< PLFLT >(val4);
16497  ecode5 = SWIG_AsVal_int(args(4), &val5);
16498  if (!SWIG_IsOK(ecode5)) {
16499  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
16500  }
16501  arg5 = static_cast< PLINT >(val5);
16502  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
16503  if (!SWIG_IsOK(res6)) {
16504  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
16505  }
16506  arg6 = reinterpret_cast< char * >(buf6);
16507  ecode7 = SWIG_AsVal_double(args(6), &val7);
16508  if (!SWIG_IsOK(ecode7)) {
16509  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
16510  }
16511  arg7 = static_cast< PLFLT >(val7);
16512  ecode8 = SWIG_AsVal_int(args(7), &val8);
16513  if (!SWIG_IsOK(ecode8)) {
16514  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
16515  }
16516  arg8 = static_cast< PLINT >(val8);
16517  plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
16518  _outv = octave_value();
16519  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16520  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16521  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16522  return _out;
16523 fail:
16524  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16525  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16526  return octave_value_list();
16527 }
16528 
16529 
16531  PLINT arg1 ;
16532  PLFLT *arg2 = (PLFLT *) 0 ;
16533  PLFLT *arg3 = (PLFLT *) 0 ;
16534  PLINT arg4 ;
16535  Matrix temp1 ;
16536  Matrix temp3 ;
16537  int val4 ;
16538  int ecode4 = 0 ;
16539  octave_value_list _out;
16540  octave_value_list *_outp=&_out;
16541  octave_value _outv;
16542 
16543  if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
16544  SWIG_fail;
16545  }
16546  {
16547  if ( _n_dims( args(0) ) > 1 )
16548  {
16549  error( "argument must be a scalar or vector" ); SWIG_fail;
16550  }
16551  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16552  temp1 = args(0).matrix_value();
16553  arg2 = &temp1( 0, 0 );
16554  }
16555  {
16556  if ( _n_dims( args(1) ) > 1 )
16557  {
16558  error( "argument must be a scalar or vector" ); SWIG_fail;
16559  }
16560  if ( _dim( args(1), 0 ) != Alen )
16561  {
16562  error( "argument vectors must be same length" ); SWIG_fail;
16563  }
16564  temp3 = args(1).matrix_value();
16565  arg3 = &temp3( 0, 0 );
16566  }
16567  ecode4 = SWIG_AsVal_int(args(2), &val4);
16568  if (!SWIG_IsOK(ecode4)) {
16569  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
16570  }
16571  arg4 = static_cast< PLINT >(val4);
16572  plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
16573  _outv = octave_value();
16574  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16575  {
16576 
16577  }
16578  {
16579 
16580  }
16581  return _out;
16582 fail:
16583  {
16584 
16585  }
16586  {
16587 
16588  }
16589  return octave_value_list();
16590 }
16591 
16592 
16594  PLINT *arg1 = (PLINT *) 0 ;
16595  PLINT *arg2 = (PLINT *) 0 ;
16596  PLINT *arg3 = (PLINT *) 0 ;
16597  PLINT *arg4 = (PLINT *) 0 ;
16598  PLINT *arg5 = (PLINT *) 0 ;
16599  PLFLT *arg6 = (PLFLT *) 0 ;
16600  PLFLT arg7 ;
16601  PLINT temp1 ;
16602  int res1 = SWIG_TMPOBJ ;
16603  PLINT temp2 ;
16604  int res2 = SWIG_TMPOBJ ;
16605  PLINT temp3 ;
16606  int res3 = SWIG_TMPOBJ ;
16607  PLINT temp4 ;
16608  int res4 = SWIG_TMPOBJ ;
16609  PLINT temp5 ;
16610  int res5 = SWIG_TMPOBJ ;
16611  PLFLT temp6 ;
16612  int res6 = SWIG_TMPOBJ ;
16613  double val7 ;
16614  int ecode7 = 0 ;
16615  octave_value_list _out;
16616  octave_value_list *_outp=&_out;
16617  octave_value _outv;
16618 
16619  arg1 = &temp1;
16620  arg2 = &temp2;
16621  arg3 = &temp3;
16622  arg4 = &temp4;
16623  arg5 = &temp5;
16624  arg6 = &temp6;
16625  if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
16626  SWIG_fail;
16627  }
16628  ecode7 = SWIG_AsVal_double(args(0), &val7);
16629  if (!SWIG_IsOK(ecode7)) {
16630  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
16631  }
16632  arg7 = static_cast< PLFLT >(val7);
16633  plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16634  _outv = octave_value();
16635  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16636  if (SWIG_IsTmpObj(res1)) {
16637  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16638  } else {
16639  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16640  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16641  }
16642  if (SWIG_IsTmpObj(res2)) {
16643  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16644  } else {
16645  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16646  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16647  }
16648  if (SWIG_IsTmpObj(res3)) {
16649  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16650  } else {
16651  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16652  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16653  }
16654  if (SWIG_IsTmpObj(res4)) {
16655  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
16656  } else {
16657  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16658  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16659  }
16660  if (SWIG_IsTmpObj(res5)) {
16661  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
16662  } else {
16663  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16664  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16665  }
16666  if (SWIG_IsTmpObj(res6)) {
16667  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
16668  } else {
16669  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16670  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
16671  }
16672  return _out;
16673 fail:
16674  return octave_value_list();
16675 }
16676 
16677 
16679  octave_value_list _out;
16680  octave_value_list *_outp=&_out;
16681  octave_value _outv;
16682 
16683  if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
16684  SWIG_fail;
16685  }
16686  plbop();
16687  _outv = octave_value();
16688  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16689  return _out;
16690 fail:
16691  return octave_value_list();
16692 }
16693 
16694 
16696  char *arg1 = (char *) 0 ;
16697  PLFLT arg2 ;
16698  PLINT arg3 ;
16699  char *arg4 = (char *) 0 ;
16700  PLFLT arg5 ;
16701  PLINT arg6 ;
16702  int res1 ;
16703  char *buf1 = 0 ;
16704  int alloc1 = 0 ;
16705  double val2 ;
16706  int ecode2 = 0 ;
16707  int val3 ;
16708  int ecode3 = 0 ;
16709  int res4 ;
16710  char *buf4 = 0 ;
16711  int alloc4 = 0 ;
16712  double val5 ;
16713  int ecode5 = 0 ;
16714  int val6 ;
16715  int ecode6 = 0 ;
16716  octave_value_list _out;
16717  octave_value_list *_outp=&_out;
16718  octave_value _outv;
16719 
16720  if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
16721  SWIG_fail;
16722  }
16723  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16724  if (!SWIG_IsOK(res1)) {
16725  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
16726  }
16727  arg1 = reinterpret_cast< char * >(buf1);
16728  ecode2 = SWIG_AsVal_double(args(1), &val2);
16729  if (!SWIG_IsOK(ecode2)) {
16730  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
16731  }
16732  arg2 = static_cast< PLFLT >(val2);
16733  ecode3 = SWIG_AsVal_int(args(2), &val3);
16734  if (!SWIG_IsOK(ecode3)) {
16735  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
16736  }
16737  arg3 = static_cast< PLINT >(val3);
16738  res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
16739  if (!SWIG_IsOK(res4)) {
16740  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
16741  }
16742  arg4 = reinterpret_cast< char * >(buf4);
16743  ecode5 = SWIG_AsVal_double(args(4), &val5);
16744  if (!SWIG_IsOK(ecode5)) {
16745  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
16746  }
16747  arg5 = static_cast< PLFLT >(val5);
16748  ecode6 = SWIG_AsVal_int(args(5), &val6);
16749  if (!SWIG_IsOK(ecode6)) {
16750  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
16751  }
16752  arg6 = static_cast< PLINT >(val6);
16753  plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
16754  _outv = octave_value();
16755  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16756  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16757  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
16758  return _out;
16759 fail:
16760  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16761  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
16762  return octave_value_list();
16763 }
16764 
16765 
16767  char *arg1 = (char *) 0 ;
16768  char *arg2 = (char *) 0 ;
16769  PLFLT arg3 ;
16770  PLINT arg4 ;
16771  char *arg5 = (char *) 0 ;
16772  char *arg6 = (char *) 0 ;
16773  PLFLT arg7 ;
16774  PLINT arg8 ;
16775  char *arg9 = (char *) 0 ;
16776  char *arg10 = (char *) 0 ;
16777  PLFLT arg11 ;
16778  PLINT arg12 ;
16779  int res1 ;
16780  char *buf1 = 0 ;
16781  int alloc1 = 0 ;
16782  int res2 ;
16783  char *buf2 = 0 ;
16784  int alloc2 = 0 ;
16785  double val3 ;
16786  int ecode3 = 0 ;
16787  int val4 ;
16788  int ecode4 = 0 ;
16789  int res5 ;
16790  char *buf5 = 0 ;
16791  int alloc5 = 0 ;
16792  int res6 ;
16793  char *buf6 = 0 ;
16794  int alloc6 = 0 ;
16795  double val7 ;
16796  int ecode7 = 0 ;
16797  int val8 ;
16798  int ecode8 = 0 ;
16799  int res9 ;
16800  char *buf9 = 0 ;
16801  int alloc9 = 0 ;
16802  int res10 ;
16803  char *buf10 = 0 ;
16804  int alloc10 = 0 ;
16805  double val11 ;
16806  int ecode11 = 0 ;
16807  int val12 ;
16808  int ecode12 = 0 ;
16809  octave_value_list _out;
16810  octave_value_list *_outp=&_out;
16811  octave_value _outv;
16812 
16813  if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
16814  SWIG_fail;
16815  }
16816  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16817  if (!SWIG_IsOK(res1)) {
16818  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
16819  }
16820  arg1 = reinterpret_cast< char * >(buf1);
16821  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
16822  if (!SWIG_IsOK(res2)) {
16823  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
16824  }
16825  arg2 = reinterpret_cast< char * >(buf2);
16826  ecode3 = SWIG_AsVal_double(args(2), &val3);
16827  if (!SWIG_IsOK(ecode3)) {
16828  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
16829  }
16830  arg3 = static_cast< PLFLT >(val3);
16831  ecode4 = SWIG_AsVal_int(args(3), &val4);
16832  if (!SWIG_IsOK(ecode4)) {
16833  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
16834  }
16835  arg4 = static_cast< PLINT >(val4);
16836  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
16837  if (!SWIG_IsOK(res5)) {
16838  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
16839  }
16840  arg5 = reinterpret_cast< char * >(buf5);
16841  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
16842  if (!SWIG_IsOK(res6)) {
16843  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
16844  }
16845  arg6 = reinterpret_cast< char * >(buf6);
16846  ecode7 = SWIG_AsVal_double(args(6), &val7);
16847  if (!SWIG_IsOK(ecode7)) {
16848  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
16849  }
16850  arg7 = static_cast< PLFLT >(val7);
16851  ecode8 = SWIG_AsVal_int(args(7), &val8);
16852  if (!SWIG_IsOK(ecode8)) {
16853  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
16854  }
16855  arg8 = static_cast< PLINT >(val8);
16856  res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
16857  if (!SWIG_IsOK(res9)) {
16858  SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
16859  }
16860  arg9 = reinterpret_cast< char * >(buf9);
16861  res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
16862  if (!SWIG_IsOK(res10)) {
16863  SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
16864  }
16865  arg10 = reinterpret_cast< char * >(buf10);
16866  ecode11 = SWIG_AsVal_double(args(10), &val11);
16867  if (!SWIG_IsOK(ecode11)) {
16868  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
16869  }
16870  arg11 = static_cast< PLFLT >(val11);
16871  ecode12 = SWIG_AsVal_int(args(11), &val12);
16872  if (!SWIG_IsOK(ecode12)) {
16873  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
16874  }
16875  arg12 = static_cast< PLINT >(val12);
16876  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);
16877  _outv = octave_value();
16878  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16879  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16880  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16881  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16882  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16883  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
16884  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
16885  return _out;
16886 fail:
16887  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16888  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16889  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16890  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16891  if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
16892  if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
16893  return octave_value_list();
16894 }
16895 
16896 
16898  PLFLT arg1 ;
16899  PLFLT arg2 ;
16900  PLFLT *arg3 = (PLFLT *) 0 ;
16901  PLFLT *arg4 = (PLFLT *) 0 ;
16902  PLINT *arg5 = (PLINT *) 0 ;
16903  double val1 ;
16904  int ecode1 = 0 ;
16905  double val2 ;
16906  int ecode2 = 0 ;
16907  PLFLT temp3 ;
16908  int res3 = SWIG_TMPOBJ ;
16909  PLFLT temp4 ;
16910  int res4 = SWIG_TMPOBJ ;
16911  PLINT temp5 ;
16912  int res5 = SWIG_TMPOBJ ;
16913  octave_value_list _out;
16914  octave_value_list *_outp=&_out;
16915  octave_value _outv;
16916 
16917  arg3 = &temp3;
16918  arg4 = &temp4;
16919  arg5 = &temp5;
16920  if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
16921  SWIG_fail;
16922  }
16923  ecode1 = SWIG_AsVal_double(args(0), &val1);
16924  if (!SWIG_IsOK(ecode1)) {
16925  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
16926  }
16927  arg1 = static_cast< PLFLT >(val1);
16928  ecode2 = SWIG_AsVal_double(args(1), &val2);
16929  if (!SWIG_IsOK(ecode2)) {
16930  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
16931  }
16932  arg2 = static_cast< PLFLT >(val2);
16933  plcalc_world(arg1,arg2,arg3,arg4,arg5);
16934  _outv = octave_value();
16935  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16936  if (SWIG_IsTmpObj(res3)) {
16937  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
16938  } else {
16939  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16940  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
16941  }
16942  if (SWIG_IsTmpObj(res4)) {
16943  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
16944  } else {
16945  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16946  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
16947  }
16948  if (SWIG_IsTmpObj(res5)) {
16949  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
16950  } else {
16951  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16952  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16953  }
16954  return _out;
16955 fail:
16956  return octave_value_list();
16957 }
16958 
16959 
16961  octave_value_list _out;
16962  octave_value_list *_outp=&_out;
16963  octave_value _outv;
16964 
16965  if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
16966  SWIG_fail;
16967  }
16968  plclear();
16969  _outv = octave_value();
16970  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16971  return _out;
16972 fail:
16973  return octave_value_list();
16974 }
16975 
16976 
16978  PLINT arg1 ;
16979  int val1 ;
16980  int ecode1 = 0 ;
16981  octave_value_list _out;
16982  octave_value_list *_outp=&_out;
16983  octave_value _outv;
16984 
16985  if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
16986  SWIG_fail;
16987  }
16988  ecode1 = SWIG_AsVal_int(args(0), &val1);
16989  if (!SWIG_IsOK(ecode1)) {
16990  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
16991  }
16992  arg1 = static_cast< PLINT >(val1);
16993  plcol0(arg1);
16994  _outv = octave_value();
16995  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16996  return _out;
16997 fail:
16998  return octave_value_list();
16999 }
17000 
17001 
17003  PLFLT arg1 ;
17004  double val1 ;
17005  int ecode1 = 0 ;
17006  octave_value_list _out;
17007  octave_value_list *_outp=&_out;
17008  octave_value _outv;
17009 
17010  if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17011  SWIG_fail;
17012  }
17013  ecode1 = SWIG_AsVal_double(args(0), &val1);
17014  if (!SWIG_IsOK(ecode1)) {
17015  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17016  }
17017  arg1 = static_cast< PLFLT >(val1);
17018  plcol1(arg1);
17019  _outv = octave_value();
17020  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17021  return _out;
17022 fail:
17023  return octave_value_list();
17024 }
17025 
17026 
17028  PLFLT arg1 ;
17029  PLFLT arg2 ;
17030  PLFLT arg3 ;
17031  PLINT arg4 ;
17032  PLBOOL arg5 ;
17033  PLINT arg6 ;
17034  PLINT arg7 ;
17035  PLINT arg8 ;
17036  PLINT arg9 ;
17037  PLINT arg10 ;
17038  PLFLT arg11 ;
17039  double val1 ;
17040  int ecode1 = 0 ;
17041  double val2 ;
17042  int ecode2 = 0 ;
17043  double val3 ;
17044  int ecode3 = 0 ;
17045  int val4 ;
17046  int ecode4 = 0 ;
17047  int val5 ;
17048  int ecode5 = 0 ;
17049  int val6 ;
17050  int ecode6 = 0 ;
17051  int val7 ;
17052  int ecode7 = 0 ;
17053  int val8 ;
17054  int ecode8 = 0 ;
17055  int val9 ;
17056  int ecode9 = 0 ;
17057  int val10 ;
17058  int ecode10 = 0 ;
17059  double val11 ;
17060  int ecode11 = 0 ;
17061  octave_value_list _out;
17062  octave_value_list *_outp=&_out;
17063  octave_value _outv;
17064 
17065  if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
17066  SWIG_fail;
17067  }
17068  ecode1 = SWIG_AsVal_double(args(0), &val1);
17069  if (!SWIG_IsOK(ecode1)) {
17070  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
17071  }
17072  arg1 = static_cast< PLFLT >(val1);
17073  ecode2 = SWIG_AsVal_double(args(1), &val2);
17074  if (!SWIG_IsOK(ecode2)) {
17075  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
17076  }
17077  arg2 = static_cast< PLFLT >(val2);
17078  ecode3 = SWIG_AsVal_double(args(2), &val3);
17079  if (!SWIG_IsOK(ecode3)) {
17080  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
17081  }
17082  arg3 = static_cast< PLFLT >(val3);
17083  ecode4 = SWIG_AsVal_int(args(3), &val4);
17084  if (!SWIG_IsOK(ecode4)) {
17085  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
17086  }
17087  arg4 = static_cast< PLINT >(val4);
17088  ecode5 = SWIG_AsVal_int(args(4), &val5);
17089  if (!SWIG_IsOK(ecode5)) {
17090  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
17091  }
17092  arg5 = static_cast< PLBOOL >(val5);
17093  ecode6 = SWIG_AsVal_int(args(5), &val6);
17094  if (!SWIG_IsOK(ecode6)) {
17095  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
17096  }
17097  arg6 = static_cast< PLINT >(val6);
17098  ecode7 = SWIG_AsVal_int(args(6), &val7);
17099  if (!SWIG_IsOK(ecode7)) {
17100  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
17101  }
17102  arg7 = static_cast< PLINT >(val7);
17103  ecode8 = SWIG_AsVal_int(args(7), &val8);
17104  if (!SWIG_IsOK(ecode8)) {
17105  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
17106  }
17107  arg8 = static_cast< PLINT >(val8);
17108  ecode9 = SWIG_AsVal_int(args(8), &val9);
17109  if (!SWIG_IsOK(ecode9)) {
17110  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
17111  }
17112  arg9 = static_cast< PLINT >(val9);
17113  ecode10 = SWIG_AsVal_int(args(9), &val10);
17114  if (!SWIG_IsOK(ecode10)) {
17115  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
17116  }
17117  arg10 = static_cast< PLINT >(val10);
17118  ecode11 = SWIG_AsVal_double(args(10), &val11);
17119  if (!SWIG_IsOK(ecode11)) {
17120  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
17121  }
17122  arg11 = static_cast< PLFLT >(val11);
17123  plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
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 
17131 
17133  PLINT arg1 ;
17134  PLINT arg2 ;
17135  PLINT arg3 ;
17136  PLINT arg4 ;
17137  PLINT arg5 ;
17138  PLFLT arg6 ;
17139  PLFLT *arg7 = (PLFLT *) 0 ;
17140  int val1 ;
17141  int ecode1 = 0 ;
17142  int val2 ;
17143  int ecode2 = 0 ;
17144  int val3 ;
17145  int ecode3 = 0 ;
17146  int val4 ;
17147  int ecode4 = 0 ;
17148  int val5 ;
17149  int ecode5 = 0 ;
17150  double val6 ;
17151  int ecode6 = 0 ;
17152  PLFLT temp7 ;
17153  int res7 = SWIG_TMPOBJ ;
17154  octave_value_list _out;
17155  octave_value_list *_outp=&_out;
17156  octave_value _outv;
17157 
17158  arg7 = &temp7;
17159  if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
17160  SWIG_fail;
17161  }
17162  ecode1 = SWIG_AsVal_int(args(0), &val1);
17163  if (!SWIG_IsOK(ecode1)) {
17164  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
17165  }
17166  arg1 = static_cast< PLINT >(val1);
17167  ecode2 = SWIG_AsVal_int(args(1), &val2);
17168  if (!SWIG_IsOK(ecode2)) {
17169  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
17170  }
17171  arg2 = static_cast< PLINT >(val2);
17172  ecode3 = SWIG_AsVal_int(args(2), &val3);
17173  if (!SWIG_IsOK(ecode3)) {
17174  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
17175  }
17176  arg3 = static_cast< PLINT >(val3);
17177  ecode4 = SWIG_AsVal_int(args(3), &val4);
17178  if (!SWIG_IsOK(ecode4)) {
17179  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
17180  }
17181  arg4 = static_cast< PLINT >(val4);
17182  ecode5 = SWIG_AsVal_int(args(4), &val5);
17183  if (!SWIG_IsOK(ecode5)) {
17184  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
17185  }
17186  arg5 = static_cast< PLINT >(val5);
17187  ecode6 = SWIG_AsVal_double(args(5), &val6);
17188  if (!SWIG_IsOK(ecode6)) {
17189  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
17190  }
17191  arg6 = static_cast< PLFLT >(val6);
17192  plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17193  _outv = octave_value();
17194  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17195  if (SWIG_IsTmpObj(res7)) {
17196  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
17197  } else {
17198  int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17199  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
17200  }
17201  return _out;
17202 fail:
17203  return octave_value_list();
17204 }
17205 
17206 
17208  PLINT arg1 ;
17209  PLBOOL arg2 ;
17210  int val1 ;
17211  int ecode1 = 0 ;
17212  int val2 ;
17213  int ecode2 = 0 ;
17214  octave_value_list _out;
17215  octave_value_list *_outp=&_out;
17216  octave_value _outv;
17217 
17218  if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
17219  SWIG_fail;
17220  }
17221  ecode1 = SWIG_AsVal_int(args(0), &val1);
17222  if (!SWIG_IsOK(ecode1)) {
17223  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
17224  }
17225  arg1 = static_cast< PLINT >(val1);
17226  ecode2 = SWIG_AsVal_int(args(1), &val2);
17227  if (!SWIG_IsOK(ecode2)) {
17228  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
17229  }
17230  arg2 = static_cast< PLBOOL >(val2);
17231  plcpstrm(arg1,arg2);
17232  _outv = octave_value();
17233  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17234  return _out;
17235 fail:
17236  return octave_value_list();
17237 }
17238 
17239 
17241  octave_value_list _out;
17242  octave_value_list *_outp=&_out;
17243  octave_value _outv;
17244 
17245  if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
17246  SWIG_fail;
17247  }
17248  plend();
17249  _outv = octave_value();
17250  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17251  return _out;
17252 fail:
17253  return octave_value_list();
17254 }
17255 
17256 
17258  octave_value_list _out;
17259  octave_value_list *_outp=&_out;
17260  octave_value _outv;
17261 
17262  if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
17263  SWIG_fail;
17264  }
17265  plend1();
17266  _outv = octave_value();
17267  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17268  return _out;
17269 fail:
17270  return octave_value_list();
17271 }
17272 
17273 
17275  PLFLT arg1 ;
17276  PLFLT arg2 ;
17277  PLFLT arg3 ;
17278  PLFLT arg4 ;
17279  PLINT arg5 ;
17280  PLINT arg6 ;
17281  double val1 ;
17282  int ecode1 = 0 ;
17283  double val2 ;
17284  int ecode2 = 0 ;
17285  double val3 ;
17286  int ecode3 = 0 ;
17287  double val4 ;
17288  int ecode4 = 0 ;
17289  int val5 ;
17290  int ecode5 = 0 ;
17291  int val6 ;
17292  int ecode6 = 0 ;
17293  octave_value_list _out;
17294  octave_value_list *_outp=&_out;
17295  octave_value _outv;
17296 
17297  if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
17298  SWIG_fail;
17299  }
17300  ecode1 = SWIG_AsVal_double(args(0), &val1);
17301  if (!SWIG_IsOK(ecode1)) {
17302  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
17303  }
17304  arg1 = static_cast< PLFLT >(val1);
17305  ecode2 = SWIG_AsVal_double(args(1), &val2);
17306  if (!SWIG_IsOK(ecode2)) {
17307  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
17308  }
17309  arg2 = static_cast< PLFLT >(val2);
17310  ecode3 = SWIG_AsVal_double(args(2), &val3);
17311  if (!SWIG_IsOK(ecode3)) {
17312  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
17313  }
17314  arg3 = static_cast< PLFLT >(val3);
17315  ecode4 = SWIG_AsVal_double(args(3), &val4);
17316  if (!SWIG_IsOK(ecode4)) {
17317  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
17318  }
17319  arg4 = static_cast< PLFLT >(val4);
17320  ecode5 = SWIG_AsVal_int(args(4), &val5);
17321  if (!SWIG_IsOK(ecode5)) {
17322  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
17323  }
17324  arg5 = static_cast< PLINT >(val5);
17325  ecode6 = SWIG_AsVal_int(args(5), &val6);
17326  if (!SWIG_IsOK(ecode6)) {
17327  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
17328  }
17329  arg6 = static_cast< PLINT >(val6);
17330  plenv(arg1,arg2,arg3,arg4,arg5,arg6);
17331  _outv = octave_value();
17332  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17333  return _out;
17334 fail:
17335  return octave_value_list();
17336 }
17337 
17338 
17340  PLFLT arg1 ;
17341  PLFLT arg2 ;
17342  PLFLT arg3 ;
17343  PLFLT arg4 ;
17344  PLINT arg5 ;
17345  PLINT arg6 ;
17346  double val1 ;
17347  int ecode1 = 0 ;
17348  double val2 ;
17349  int ecode2 = 0 ;
17350  double val3 ;
17351  int ecode3 = 0 ;
17352  double val4 ;
17353  int ecode4 = 0 ;
17354  int val5 ;
17355  int ecode5 = 0 ;
17356  int val6 ;
17357  int ecode6 = 0 ;
17358  octave_value_list _out;
17359  octave_value_list *_outp=&_out;
17360  octave_value _outv;
17361 
17362  if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
17363  SWIG_fail;
17364  }
17365  ecode1 = SWIG_AsVal_double(args(0), &val1);
17366  if (!SWIG_IsOK(ecode1)) {
17367  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
17368  }
17369  arg1 = static_cast< PLFLT >(val1);
17370  ecode2 = SWIG_AsVal_double(args(1), &val2);
17371  if (!SWIG_IsOK(ecode2)) {
17372  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
17373  }
17374  arg2 = static_cast< PLFLT >(val2);
17375  ecode3 = SWIG_AsVal_double(args(2), &val3);
17376  if (!SWIG_IsOK(ecode3)) {
17377  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
17378  }
17379  arg3 = static_cast< PLFLT >(val3);
17380  ecode4 = SWIG_AsVal_double(args(3), &val4);
17381  if (!SWIG_IsOK(ecode4)) {
17382  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
17383  }
17384  arg4 = static_cast< PLFLT >(val4);
17385  ecode5 = SWIG_AsVal_int(args(4), &val5);
17386  if (!SWIG_IsOK(ecode5)) {
17387  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
17388  }
17389  arg5 = static_cast< PLINT >(val5);
17390  ecode6 = SWIG_AsVal_int(args(5), &val6);
17391  if (!SWIG_IsOK(ecode6)) {
17392  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
17393  }
17394  arg6 = static_cast< PLINT >(val6);
17395  plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
17396  _outv = octave_value();
17397  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17398  return _out;
17399 fail:
17400  return octave_value_list();
17401 }
17402 
17403 
17405  octave_value_list _out;
17406  octave_value_list *_outp=&_out;
17407  octave_value _outv;
17408 
17409  if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
17410  SWIG_fail;
17411  }
17412  pleop();
17413  _outv = octave_value();
17414  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17415  return _out;
17416 fail:
17417  return octave_value_list();
17418 }
17419 
17420 
17422  PLINT arg1 ;
17423  PLFLT *arg2 = (PLFLT *) 0 ;
17424  PLFLT *arg3 = (PLFLT *) 0 ;
17425  PLFLT *arg4 = (PLFLT *) 0 ;
17426  Matrix temp1 ;
17427  Matrix temp3 ;
17428  Matrix temp4 ;
17429  octave_value_list _out;
17430  octave_value_list *_outp=&_out;
17431  octave_value _outv;
17432 
17433  if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
17434  SWIG_fail;
17435  }
17436  {
17437  if ( _n_dims( args(0) ) > 1 )
17438  {
17439  error( "argument must be a scalar or vector" ); SWIG_fail;
17440  }
17441  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17442  temp1 = args(0).matrix_value();
17443  arg2 = &temp1( 0, 0 );
17444  }
17445  {
17446  if ( _n_dims( args(1) ) > 1 )
17447  {
17448  error( "argument must be a scalar or vector" ); SWIG_fail;
17449  }
17450  if ( _dim( args(1), 0 ) != Alen )
17451  {
17452  error( "argument vectors must be same length" ); SWIG_fail;
17453  }
17454  temp3 = args(1).matrix_value();
17455  arg3 = &temp3( 0, 0 );
17456  }
17457  {
17458  if ( _n_dims( args(2) ) > 1 )
17459  {
17460  error( "argument must be a scalar or vector" ); SWIG_fail;
17461  }
17462  if ( _dim( args(2), 0 ) != Alen )
17463  {
17464  error( "argument vectors must be same length" ); SWIG_fail;
17465  }
17466  temp4 = args(2).matrix_value();
17467  arg4 = &temp4( 0, 0 );
17468  }
17469  plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17470  _outv = octave_value();
17471  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17472  {
17473 
17474  }
17475  {
17476 
17477  }
17478  {
17479 
17480  }
17481  return _out;
17482 fail:
17483  {
17484 
17485  }
17486  {
17487 
17488  }
17489  {
17490 
17491  }
17492  return octave_value_list();
17493 }
17494 
17495 
17497  PLINT arg1 ;
17498  PLFLT *arg2 = (PLFLT *) 0 ;
17499  PLFLT *arg3 = (PLFLT *) 0 ;
17500  PLFLT *arg4 = (PLFLT *) 0 ;
17501  Matrix temp1 ;
17502  Matrix temp3 ;
17503  Matrix temp4 ;
17504  octave_value_list _out;
17505  octave_value_list *_outp=&_out;
17506  octave_value _outv;
17507 
17508  if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
17509  SWIG_fail;
17510  }
17511  {
17512  if ( _n_dims( args(0) ) > 1 )
17513  {
17514  error( "argument must be a scalar or vector" ); SWIG_fail;
17515  }
17516  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17517  temp1 = args(0).matrix_value();
17518  arg2 = &temp1( 0, 0 );
17519  }
17520  {
17521  if ( _n_dims( args(1) ) > 1 )
17522  {
17523  error( "argument must be a scalar or vector" ); SWIG_fail;
17524  }
17525  if ( _dim( args(1), 0 ) != Alen )
17526  {
17527  error( "argument vectors must be same length" ); SWIG_fail;
17528  }
17529  temp3 = args(1).matrix_value();
17530  arg3 = &temp3( 0, 0 );
17531  }
17532  {
17533  if ( _n_dims( args(2) ) > 1 )
17534  {
17535  error( "argument must be a scalar or vector" ); SWIG_fail;
17536  }
17537  if ( _dim( args(2), 0 ) != Alen )
17538  {
17539  error( "argument vectors must be same length" ); SWIG_fail;
17540  }
17541  temp4 = args(2).matrix_value();
17542  arg4 = &temp4( 0, 0 );
17543  }
17544  plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17545  _outv = octave_value();
17546  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17547  {
17548 
17549  }
17550  {
17551 
17552  }
17553  {
17554 
17555  }
17556  return _out;
17557 fail:
17558  {
17559 
17560  }
17561  {
17562 
17563  }
17564  {
17565 
17566  }
17567  return octave_value_list();
17568 }
17569 
17570 
17572  octave_value_list _out;
17573  octave_value_list *_outp=&_out;
17574  octave_value _outv;
17575 
17576  if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
17577  SWIG_fail;
17578  }
17579  plfamadv();
17580  _outv = octave_value();
17581  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17582  return _out;
17583 fail:
17584  return octave_value_list();
17585 }
17586 
17587 
17589  PLINT arg1 ;
17590  PLFLT *arg2 = (PLFLT *) 0 ;
17591  PLFLT *arg3 = (PLFLT *) 0 ;
17592  Matrix temp1 ;
17593  Matrix temp3 ;
17594  octave_value_list _out;
17595  octave_value_list *_outp=&_out;
17596  octave_value _outv;
17597 
17598  if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
17599  SWIG_fail;
17600  }
17601  {
17602  if ( _n_dims( args(0) ) > 1 )
17603  {
17604  error( "argument must be a scalar or vector" ); SWIG_fail;
17605  }
17606  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17607  temp1 = args(0).matrix_value();
17608  arg2 = &temp1( 0, 0 );
17609  }
17610  {
17611  if ( _n_dims( args(1) ) > 1 )
17612  {
17613  error( "argument must be a scalar or vector" ); SWIG_fail;
17614  }
17615  if ( _dim( args(1), 0 ) != Alen )
17616  {
17617  error( "argument vectors must be same length" ); SWIG_fail;
17618  }
17619  temp3 = args(1).matrix_value();
17620  arg3 = &temp3( 0, 0 );
17621  }
17622  plfill(arg1,(double const *)arg2,(double const *)arg3);
17623  _outv = octave_value();
17624  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17625  {
17626 
17627  }
17628  {
17629 
17630  }
17631  return _out;
17632 fail:
17633  {
17634 
17635  }
17636  {
17637 
17638  }
17639  return octave_value_list();
17640 }
17641 
17642 
17644  PLINT arg1 ;
17645  PLFLT *arg2 = (PLFLT *) 0 ;
17646  PLFLT *arg3 = (PLFLT *) 0 ;
17647  PLFLT *arg4 = (PLFLT *) 0 ;
17648  Matrix temp1 ;
17649  Matrix temp3 ;
17650  Matrix temp4 ;
17651  octave_value_list _out;
17652  octave_value_list *_outp=&_out;
17653  octave_value _outv;
17654 
17655  if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
17656  SWIG_fail;
17657  }
17658  {
17659  if ( _n_dims( args(0) ) > 1 )
17660  {
17661  error( "argument must be a scalar or vector" ); SWIG_fail;
17662  }
17663  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17664  temp1 = args(0).matrix_value();
17665  arg2 = &temp1( 0, 0 );
17666  }
17667  {
17668  if ( _n_dims( args(1) ) > 1 )
17669  {
17670  error( "argument must be a scalar or vector" ); SWIG_fail;
17671  }
17672  if ( _dim( args(1), 0 ) != Alen )
17673  {
17674  error( "argument vectors must be same length" ); SWIG_fail;
17675  }
17676  temp3 = args(1).matrix_value();
17677  arg3 = &temp3( 0, 0 );
17678  }
17679  {
17680  if ( _n_dims( args(2) ) > 1 )
17681  {
17682  error( "argument must be a scalar or vector" ); SWIG_fail;
17683  }
17684  if ( _dim( args(2), 0 ) != Alen )
17685  {
17686  error( "argument vectors must be same length" ); SWIG_fail;
17687  }
17688  temp4 = args(2).matrix_value();
17689  arg4 = &temp4( 0, 0 );
17690  }
17691  plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17692  _outv = octave_value();
17693  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17694  {
17695 
17696  }
17697  {
17698 
17699  }
17700  {
17701 
17702  }
17703  return _out;
17704 fail:
17705  {
17706 
17707  }
17708  {
17709 
17710  }
17711  {
17712 
17713  }
17714  return octave_value_list();
17715 }
17716 
17717 
17719  PLINT arg1 ;
17720  PLFLT *arg2 = (PLFLT *) 0 ;
17721  PLFLT *arg3 = (PLFLT *) 0 ;
17722  PLFLT arg4 ;
17723  Matrix temp1 ;
17724  Matrix temp3 ;
17725  double val4 ;
17726  int ecode4 = 0 ;
17727  octave_value_list _out;
17728  octave_value_list *_outp=&_out;
17729  octave_value _outv;
17730 
17731  if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
17732  SWIG_fail;
17733  }
17734  {
17735  if ( _n_dims( args(0) ) > 1 )
17736  {
17737  error( "argument must be a scalar or vector" ); SWIG_fail;
17738  }
17739  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17740  temp1 = args(0).matrix_value();
17741  arg2 = &temp1( 0, 0 );
17742  }
17743  {
17744  if ( _n_dims( args(1) ) > 1 )
17745  {
17746  error( "argument must be a scalar or vector" ); SWIG_fail;
17747  }
17748  if ( _dim( args(1), 0 ) != Alen )
17749  {
17750  error( "argument vectors must be same length" ); SWIG_fail;
17751  }
17752  temp3 = args(1).matrix_value();
17753  arg3 = &temp3( 0, 0 );
17754  }
17755  ecode4 = SWIG_AsVal_double(args(2), &val4);
17756  if (!SWIG_IsOK(ecode4)) {
17757  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
17758  }
17759  arg4 = static_cast< PLFLT >(val4);
17760  plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
17761  _outv = octave_value();
17762  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17763  {
17764 
17765  }
17766  {
17767 
17768  }
17769  return _out;
17770 fail:
17771  {
17772 
17773  }
17774  {
17775 
17776  }
17777  return octave_value_list();
17778 }
17779 
17780 
17782  octave_value_list _out;
17783  octave_value_list *_outp=&_out;
17784  octave_value _outv;
17785 
17786  if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
17787  SWIG_fail;
17788  }
17789  plflush();
17790  _outv = octave_value();
17791  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17792  return _out;
17793 fail:
17794  return octave_value_list();
17795 }
17796 
17797 
17799  PLINT arg1 ;
17800  int val1 ;
17801  int ecode1 = 0 ;
17802  octave_value_list _out;
17803  octave_value_list *_outp=&_out;
17804  octave_value _outv;
17805 
17806  if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
17807  SWIG_fail;
17808  }
17809  ecode1 = SWIG_AsVal_int(args(0), &val1);
17810  if (!SWIG_IsOK(ecode1)) {
17811  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
17812  }
17813  arg1 = static_cast< PLINT >(val1);
17814  plfont(arg1);
17815  _outv = octave_value();
17816  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17817  return _out;
17818 fail:
17819  return octave_value_list();
17820 }
17821 
17822 
17824  PLINT arg1 ;
17825  int val1 ;
17826  int ecode1 = 0 ;
17827  octave_value_list _out;
17828  octave_value_list *_outp=&_out;
17829  octave_value _outv;
17830 
17831  if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
17832  SWIG_fail;
17833  }
17834  ecode1 = SWIG_AsVal_int(args(0), &val1);
17835  if (!SWIG_IsOK(ecode1)) {
17836  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
17837  }
17838  arg1 = static_cast< PLINT >(val1);
17839  plfontld(arg1);
17840  _outv = octave_value();
17841  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17842  return _out;
17843 fail:
17844  return octave_value_list();
17845 }
17846 
17847 
17849  PLFLT *arg1 = (PLFLT *) 0 ;
17850  PLFLT *arg2 = (PLFLT *) 0 ;
17851  PLFLT temp1 ;
17852  int res1 = SWIG_TMPOBJ ;
17853  PLFLT temp2 ;
17854  int res2 = SWIG_TMPOBJ ;
17855  octave_value_list _out;
17856  octave_value_list *_outp=&_out;
17857  octave_value _outv;
17858 
17859  arg1 = &temp1;
17860  arg2 = &temp2;
17861  if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
17862  SWIG_fail;
17863  }
17864  plgchr(arg1,arg2);
17865  _outv = octave_value();
17866  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17867  if (SWIG_IsTmpObj(res1)) {
17868  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17869  } else {
17870  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17871  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17872  }
17873  if (SWIG_IsTmpObj(res2)) {
17874  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17875  } else {
17876  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17877  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17878  }
17879  return _out;
17880 fail:
17881  return octave_value_list();
17882 }
17883 
17884 
17886  PLINT arg1 ;
17887  PLINT *arg2 = (PLINT *) 0 ;
17888  PLINT *arg3 = (PLINT *) 0 ;
17889  PLINT *arg4 = (PLINT *) 0 ;
17890  int val1 ;
17891  int ecode1 = 0 ;
17892  PLINT temp2 ;
17893  int res2 = SWIG_TMPOBJ ;
17894  PLINT temp3 ;
17895  int res3 = SWIG_TMPOBJ ;
17896  PLINT temp4 ;
17897  int res4 = SWIG_TMPOBJ ;
17898  octave_value_list _out;
17899  octave_value_list *_outp=&_out;
17900  octave_value _outv;
17901 
17902  arg2 = &temp2;
17903  arg3 = &temp3;
17904  arg4 = &temp4;
17905  if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
17906  SWIG_fail;
17907  }
17908  ecode1 = SWIG_AsVal_int(args(0), &val1);
17909  if (!SWIG_IsOK(ecode1)) {
17910  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
17911  }
17912  arg1 = static_cast< PLINT >(val1);
17913  plgcol0(arg1,arg2,arg3,arg4);
17914  _outv = octave_value();
17915  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17916  if (SWIG_IsTmpObj(res2)) {
17917  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17918  } else {
17919  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17920  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17921  }
17922  if (SWIG_IsTmpObj(res3)) {
17923  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17924  } else {
17925  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17926  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17927  }
17928  if (SWIG_IsTmpObj(res4)) {
17929  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17930  } else {
17931  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17932  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17933  }
17934  return _out;
17935 fail:
17936  return octave_value_list();
17937 }
17938 
17939 
17941  PLINT arg1 ;
17942  PLINT *arg2 = (PLINT *) 0 ;
17943  PLINT *arg3 = (PLINT *) 0 ;
17944  PLINT *arg4 = (PLINT *) 0 ;
17945  PLFLT *arg5 = (PLFLT *) 0 ;
17946  int val1 ;
17947  int ecode1 = 0 ;
17948  PLINT temp2 ;
17949  int res2 = SWIG_TMPOBJ ;
17950  PLINT temp3 ;
17951  int res3 = SWIG_TMPOBJ ;
17952  PLINT temp4 ;
17953  int res4 = SWIG_TMPOBJ ;
17954  PLFLT temp5 ;
17955  int res5 = SWIG_TMPOBJ ;
17956  octave_value_list _out;
17957  octave_value_list *_outp=&_out;
17958  octave_value _outv;
17959 
17960  arg2 = &temp2;
17961  arg3 = &temp3;
17962  arg4 = &temp4;
17963  arg5 = &temp5;
17964  if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
17965  SWIG_fail;
17966  }
17967  ecode1 = SWIG_AsVal_int(args(0), &val1);
17968  if (!SWIG_IsOK(ecode1)) {
17969  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
17970  }
17971  arg1 = static_cast< PLINT >(val1);
17972  plgcol0a(arg1,arg2,arg3,arg4,arg5);
17973  _outv = octave_value();
17974  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17975  if (SWIG_IsTmpObj(res2)) {
17976  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17977  } else {
17978  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17979  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17980  }
17981  if (SWIG_IsTmpObj(res3)) {
17982  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17983  } else {
17984  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17985  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17986  }
17987  if (SWIG_IsTmpObj(res4)) {
17988  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17989  } else {
17990  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17991  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17992  }
17993  if (SWIG_IsTmpObj(res5)) {
17994  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
17995  } else {
17996  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17997  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
17998  }
17999  return _out;
18000 fail:
18001  return octave_value_list();
18002 }
18003 
18004 
18006  PLINT *arg1 = (PLINT *) 0 ;
18007  PLINT *arg2 = (PLINT *) 0 ;
18008  PLINT *arg3 = (PLINT *) 0 ;
18009  PLINT temp1 ;
18010  int res1 = SWIG_TMPOBJ ;
18011  PLINT temp2 ;
18012  int res2 = SWIG_TMPOBJ ;
18013  PLINT temp3 ;
18014  int res3 = SWIG_TMPOBJ ;
18015  octave_value_list _out;
18016  octave_value_list *_outp=&_out;
18017  octave_value _outv;
18018 
18019  arg1 = &temp1;
18020  arg2 = &temp2;
18021  arg3 = &temp3;
18022  if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
18023  SWIG_fail;
18024  }
18025  plgcolbg(arg1,arg2,arg3);
18026  _outv = octave_value();
18027  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18028  if (SWIG_IsTmpObj(res1)) {
18029  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18030  } else {
18031  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18032  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18033  }
18034  if (SWIG_IsTmpObj(res2)) {
18035  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18036  } else {
18037  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18038  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18039  }
18040  if (SWIG_IsTmpObj(res3)) {
18041  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18042  } else {
18043  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18044  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18045  }
18046  return _out;
18047 fail:
18048  return octave_value_list();
18049 }
18050 
18051 
18053  PLINT *arg1 = (PLINT *) 0 ;
18054  PLINT *arg2 = (PLINT *) 0 ;
18055  PLINT *arg3 = (PLINT *) 0 ;
18056  PLFLT *arg4 = (PLFLT *) 0 ;
18057  PLINT temp1 ;
18058  int res1 = SWIG_TMPOBJ ;
18059  PLINT temp2 ;
18060  int res2 = SWIG_TMPOBJ ;
18061  PLINT temp3 ;
18062  int res3 = SWIG_TMPOBJ ;
18063  PLFLT temp4 ;
18064  int res4 = SWIG_TMPOBJ ;
18065  octave_value_list _out;
18066  octave_value_list *_outp=&_out;
18067  octave_value _outv;
18068 
18069  arg1 = &temp1;
18070  arg2 = &temp2;
18071  arg3 = &temp3;
18072  arg4 = &temp4;
18073  if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
18074  SWIG_fail;
18075  }
18076  plgcolbga(arg1,arg2,arg3,arg4);
18077  _outv = octave_value();
18078  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18079  if (SWIG_IsTmpObj(res1)) {
18080  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18081  } else {
18082  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18083  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18084  }
18085  if (SWIG_IsTmpObj(res2)) {
18086  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18087  } else {
18088  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18089  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18090  }
18091  if (SWIG_IsTmpObj(res3)) {
18092  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18093  } else {
18094  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18095  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18096  }
18097  if (SWIG_IsTmpObj(res4)) {
18098  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18099  } else {
18100  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18101  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18102  }
18103  return _out;
18104 fail:
18105  return octave_value_list();
18106 }
18107 
18108 
18110  PLINT *arg1 = (PLINT *) 0 ;
18111  PLINT temp1 ;
18112  int res1 = SWIG_TMPOBJ ;
18113  octave_value_list _out;
18114  octave_value_list *_outp=&_out;
18115  octave_value _outv;
18116 
18117  arg1 = &temp1;
18118  if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
18119  SWIG_fail;
18120  }
18121  plgcompression(arg1);
18122  _outv = octave_value();
18123  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18124  if (SWIG_IsTmpObj(res1)) {
18125  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18126  } else {
18127  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18128  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18129  }
18130  return _out;
18131 fail:
18132  return octave_value_list();
18133 }
18134 
18135 
18137  char *arg1 = (char *) 0 ;
18138  char local_string1[80] ;
18139  size_t local_string_length1 ;
18140  charMatrix local_charMatrix1 ;
18141  octave_value_list retval1 ;
18142  octave_value_list _out;
18143  octave_value_list *_outp=&_out;
18144  octave_value _outv;
18145 
18146  {
18147  arg1 = local_string1;
18148  }
18149  if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
18150  SWIG_fail;
18151  }
18152  plgdev(arg1);
18153  _outv = octave_value();
18154  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18155  {
18156  local_string_length1 = strlen( local_string1 );
18157  local_charMatrix1 = charMatrix( 1, local_string_length1 );
18158  local_charMatrix1.insert( local_string1, 0, 0 );
18159  retval1( 0 ) = octave_value( local_charMatrix1 );
18160  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18161  }
18162  return _out;
18163 fail:
18164  return octave_value_list();
18165 }
18166 
18167 
18169  PLFLT *arg1 = (PLFLT *) 0 ;
18170  PLFLT *arg2 = (PLFLT *) 0 ;
18171  PLFLT *arg3 = (PLFLT *) 0 ;
18172  PLFLT *arg4 = (PLFLT *) 0 ;
18173  PLFLT temp1 ;
18174  int res1 = SWIG_TMPOBJ ;
18175  PLFLT temp2 ;
18176  int res2 = SWIG_TMPOBJ ;
18177  PLFLT temp3 ;
18178  int res3 = SWIG_TMPOBJ ;
18179  PLFLT temp4 ;
18180  int res4 = SWIG_TMPOBJ ;
18181  octave_value_list _out;
18182  octave_value_list *_outp=&_out;
18183  octave_value _outv;
18184 
18185  arg1 = &temp1;
18186  arg2 = &temp2;
18187  arg3 = &temp3;
18188  arg4 = &temp4;
18189  if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
18190  SWIG_fail;
18191  }
18192  plgdidev(arg1,arg2,arg3,arg4);
18193  _outv = octave_value();
18194  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18195  if (SWIG_IsTmpObj(res1)) {
18196  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18197  } else {
18198  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18199  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18200  }
18201  if (SWIG_IsTmpObj(res2)) {
18202  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18203  } else {
18204  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18205  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18206  }
18207  if (SWIG_IsTmpObj(res3)) {
18208  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18209  } else {
18210  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18211  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18212  }
18213  if (SWIG_IsTmpObj(res4)) {
18214  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18215  } else {
18216  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18217  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18218  }
18219  return _out;
18220 fail:
18221  return octave_value_list();
18222 }
18223 
18224 
18226  PLFLT *arg1 = (PLFLT *) 0 ;
18227  PLFLT temp1 ;
18228  int res1 = SWIG_TMPOBJ ;
18229  octave_value_list _out;
18230  octave_value_list *_outp=&_out;
18231  octave_value _outv;
18232 
18233  arg1 = &temp1;
18234  if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
18235  SWIG_fail;
18236  }
18237  plgdiori(arg1);
18238  _outv = octave_value();
18239  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18240  if (SWIG_IsTmpObj(res1)) {
18241  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18242  } else {
18243  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18244  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18245  }
18246  return _out;
18247 fail:
18248  return octave_value_list();
18249 }
18250 
18251 
18253  PLFLT *arg1 = (PLFLT *) 0 ;
18254  PLFLT *arg2 = (PLFLT *) 0 ;
18255  PLFLT *arg3 = (PLFLT *) 0 ;
18256  PLFLT *arg4 = (PLFLT *) 0 ;
18257  PLFLT temp1 ;
18258  int res1 = SWIG_TMPOBJ ;
18259  PLFLT temp2 ;
18260  int res2 = SWIG_TMPOBJ ;
18261  PLFLT temp3 ;
18262  int res3 = SWIG_TMPOBJ ;
18263  PLFLT temp4 ;
18264  int res4 = SWIG_TMPOBJ ;
18265  octave_value_list _out;
18266  octave_value_list *_outp=&_out;
18267  octave_value _outv;
18268 
18269  arg1 = &temp1;
18270  arg2 = &temp2;
18271  arg3 = &temp3;
18272  arg4 = &temp4;
18273  if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
18274  SWIG_fail;
18275  }
18276  plgdiplt(arg1,arg2,arg3,arg4);
18277  _outv = octave_value();
18278  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18279  if (SWIG_IsTmpObj(res1)) {
18280  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18281  } else {
18282  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18283  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18284  }
18285  if (SWIG_IsTmpObj(res2)) {
18286  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18287  } else {
18288  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18289  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18290  }
18291  if (SWIG_IsTmpObj(res3)) {
18292  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18293  } else {
18294  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18295  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18296  }
18297  if (SWIG_IsTmpObj(res4)) {
18298  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18299  } else {
18300  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18301  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18302  }
18303  return _out;
18304 fail:
18305  return octave_value_list();
18306 }
18307 
18308 
18310  PLINT *arg1 = (PLINT *) 0 ;
18311  PLINT *arg2 = (PLINT *) 0 ;
18312  PLINT *arg3 = (PLINT *) 0 ;
18313  PLINT temp1 ;
18314  int res1 = SWIG_TMPOBJ ;
18315  PLINT temp2 ;
18316  int res2 = SWIG_TMPOBJ ;
18317  PLINT temp3 ;
18318  int res3 = SWIG_TMPOBJ ;
18319  octave_value_list _out;
18320  octave_value_list *_outp=&_out;
18321  octave_value _outv;
18322 
18323  arg1 = &temp1;
18324  arg2 = &temp2;
18325  arg3 = &temp3;
18326  if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
18327  SWIG_fail;
18328  }
18329  plgfam(arg1,arg2,arg3);
18330  _outv = octave_value();
18331  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18332  if (SWIG_IsTmpObj(res1)) {
18333  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18334  } else {
18335  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18336  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18337  }
18338  if (SWIG_IsTmpObj(res2)) {
18339  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18340  } else {
18341  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18342  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18343  }
18344  if (SWIG_IsTmpObj(res3)) {
18345  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18346  } else {
18347  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18348  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18349  }
18350  return _out;
18351 fail:
18352  return octave_value_list();
18353 }
18354 
18355 
18357  PLUNICODE *arg1 = (PLUNICODE *) 0 ;
18358  PLUNICODE temp1 ;
18359  int res1 = SWIG_TMPOBJ ;
18360  octave_value_list _out;
18361  octave_value_list *_outp=&_out;
18362  octave_value _outv;
18363 
18364  arg1 = &temp1;
18365  if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
18366  SWIG_fail;
18367  }
18368  plgfci(arg1);
18369  _outv = octave_value();
18370  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18371  if (SWIG_IsTmpObj(res1)) {
18372  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
18373  } else {
18374  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18375  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
18376  }
18377  return _out;
18378 fail:
18379  return octave_value_list();
18380 }
18381 
18382 
18384  char *arg1 = (char *) 0 ;
18385  char local_string1[80] ;
18386  size_t local_string_length1 ;
18387  charMatrix local_charMatrix1 ;
18388  octave_value_list retval1 ;
18389  octave_value_list _out;
18390  octave_value_list *_outp=&_out;
18391  octave_value _outv;
18392 
18393  {
18394  arg1 = local_string1;
18395  }
18396  if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
18397  SWIG_fail;
18398  }
18399  plgfnam(arg1);
18400  _outv = octave_value();
18401  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18402  {
18403  local_string_length1 = strlen( local_string1 );
18404  local_charMatrix1 = charMatrix( 1, local_string_length1 );
18405  local_charMatrix1.insert( local_string1, 0, 0 );
18406  retval1( 0 ) = octave_value( local_charMatrix1 );
18407  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18408  }
18409  return _out;
18410 fail:
18411  return octave_value_list();
18412 }
18413 
18414 
18416  PLINT *arg1 = (PLINT *) 0 ;
18417  PLINT *arg2 = (PLINT *) 0 ;
18418  PLINT *arg3 = (PLINT *) 0 ;
18419  PLINT temp1 ;
18420  int res1 = SWIG_TMPOBJ ;
18421  PLINT temp2 ;
18422  int res2 = SWIG_TMPOBJ ;
18423  PLINT temp3 ;
18424  int res3 = SWIG_TMPOBJ ;
18425  octave_value_list _out;
18426  octave_value_list *_outp=&_out;
18427  octave_value _outv;
18428 
18429  arg1 = &temp1;
18430  arg2 = &temp2;
18431  arg3 = &temp3;
18432  if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
18433  SWIG_fail;
18434  }
18435  plgfont(arg1,arg2,arg3);
18436  _outv = octave_value();
18437  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18438  if (SWIG_IsTmpObj(res1)) {
18439  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18440  } else {
18441  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18442  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18443  }
18444  if (SWIG_IsTmpObj(res2)) {
18445  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18446  } else {
18447  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18448  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18449  }
18450  if (SWIG_IsTmpObj(res3)) {
18451  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18452  } else {
18453  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18454  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18455  }
18456  return _out;
18457 fail:
18458  return octave_value_list();
18459 }
18460 
18461 
18463  PLINT *arg1 = (PLINT *) 0 ;
18464  PLINT temp1 ;
18465  int res1 = SWIG_TMPOBJ ;
18466  octave_value_list _out;
18467  octave_value_list *_outp=&_out;
18468  octave_value _outv;
18469 
18470  arg1 = &temp1;
18471  if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
18472  SWIG_fail;
18473  }
18474  plglevel(arg1);
18475  _outv = octave_value();
18476  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18477  if (SWIG_IsTmpObj(res1)) {
18478  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18479  } else {
18480  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18481  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18482  }
18483  return _out;
18484 fail:
18485  return octave_value_list();
18486 }
18487 
18488 
18490  PLFLT *arg1 = (PLFLT *) 0 ;
18491  PLFLT *arg2 = (PLFLT *) 0 ;
18492  PLINT *arg3 = (PLINT *) 0 ;
18493  PLINT *arg4 = (PLINT *) 0 ;
18494  PLINT *arg5 = (PLINT *) 0 ;
18495  PLINT *arg6 = (PLINT *) 0 ;
18496  PLFLT temp1 ;
18497  int res1 = SWIG_TMPOBJ ;
18498  PLFLT temp2 ;
18499  int res2 = SWIG_TMPOBJ ;
18500  PLINT temp3 ;
18501  int res3 = SWIG_TMPOBJ ;
18502  PLINT temp4 ;
18503  int res4 = SWIG_TMPOBJ ;
18504  PLINT temp5 ;
18505  int res5 = SWIG_TMPOBJ ;
18506  PLINT temp6 ;
18507  int res6 = SWIG_TMPOBJ ;
18508  octave_value_list _out;
18509  octave_value_list *_outp=&_out;
18510  octave_value _outv;
18511 
18512  arg1 = &temp1;
18513  arg2 = &temp2;
18514  arg3 = &temp3;
18515  arg4 = &temp4;
18516  arg5 = &temp5;
18517  arg6 = &temp6;
18518  if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
18519  SWIG_fail;
18520  }
18521  plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
18522  _outv = octave_value();
18523  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18524  if (SWIG_IsTmpObj(res1)) {
18525  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18526  } else {
18527  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18528  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18529  }
18530  if (SWIG_IsTmpObj(res2)) {
18531  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18532  } else {
18533  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18534  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18535  }
18536  if (SWIG_IsTmpObj(res3)) {
18537  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18538  } else {
18539  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18540  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18541  }
18542  if (SWIG_IsTmpObj(res4)) {
18543  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18544  } else {
18545  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18546  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18547  }
18548  if (SWIG_IsTmpObj(res5)) {
18549  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
18550  } else {
18551  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18552  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
18553  }
18554  if (SWIG_IsTmpObj(res6)) {
18555  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
18556  } else {
18557  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18558  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
18559  }
18560  return _out;
18561 fail:
18562  return octave_value_list();
18563 }
18564 
18565 
18567  octave_value_list _out;
18568  octave_value_list *_outp=&_out;
18569  octave_value _outv;
18570 
18571  if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
18572  SWIG_fail;
18573  }
18574  plgra();
18575  _outv = octave_value();
18576  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18577  return _out;
18578 fail:
18579  return octave_value_list();
18580 }
18581 
18582 
18584  PLFLT *arg1 = (PLFLT *) 0 ;
18585  PLFLT *arg2 = (PLFLT *) 0 ;
18586  PLFLT *arg3 = (PLFLT *) 0 ;
18587  PLFLT *arg4 = (PLFLT *) 0 ;
18588  PLFLT temp1 ;
18589  int res1 = SWIG_TMPOBJ ;
18590  PLFLT temp2 ;
18591  int res2 = SWIG_TMPOBJ ;
18592  PLFLT temp3 ;
18593  int res3 = SWIG_TMPOBJ ;
18594  PLFLT temp4 ;
18595  int res4 = SWIG_TMPOBJ ;
18596  octave_value_list _out;
18597  octave_value_list *_outp=&_out;
18598  octave_value _outv;
18599 
18600  arg1 = &temp1;
18601  arg2 = &temp2;
18602  arg3 = &temp3;
18603  arg4 = &temp4;
18604  if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
18605  SWIG_fail;
18606  }
18607  plgspa(arg1,arg2,arg3,arg4);
18608  _outv = octave_value();
18609  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18610  if (SWIG_IsTmpObj(res1)) {
18611  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18612  } else {
18613  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18614  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18615  }
18616  if (SWIG_IsTmpObj(res2)) {
18617  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18618  } else {
18619  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18620  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18621  }
18622  if (SWIG_IsTmpObj(res3)) {
18623  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18624  } else {
18625  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18626  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18627  }
18628  if (SWIG_IsTmpObj(res4)) {
18629  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18630  } else {
18631  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18632  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18633  }
18634  return _out;
18635 fail:
18636  return octave_value_list();
18637 }
18638 
18639 
18641  PLINT *arg1 = (PLINT *) 0 ;
18642  PLINT temp1 ;
18643  int res1 = SWIG_TMPOBJ ;
18644  octave_value_list _out;
18645  octave_value_list *_outp=&_out;
18646  octave_value _outv;
18647 
18648  arg1 = &temp1;
18649  if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
18650  SWIG_fail;
18651  }
18652  plgstrm(arg1);
18653  _outv = octave_value();
18654  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18655  if (SWIG_IsTmpObj(res1)) {
18656  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18657  } else {
18658  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18659  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18660  }
18661  return _out;
18662 fail:
18663  return octave_value_list();
18664 }
18665 
18666 
18668  char *arg1 = (char *) 0 ;
18669  char local_string1[80] ;
18670  size_t local_string_length1 ;
18671  charMatrix local_charMatrix1 ;
18672  octave_value_list retval1 ;
18673  octave_value_list _out;
18674  octave_value_list *_outp=&_out;
18675  octave_value _outv;
18676 
18677  {
18678  arg1 = local_string1;
18679  }
18680  if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
18681  SWIG_fail;
18682  }
18683  plgver(arg1);
18684  _outv = octave_value();
18685  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18686  {
18687  local_string_length1 = strlen( local_string1 );
18688  local_charMatrix1 = charMatrix( 1, local_string_length1 );
18689  local_charMatrix1.insert( local_string1, 0, 0 );
18690  retval1( 0 ) = octave_value( local_charMatrix1 );
18691  _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18692  }
18693  return _out;
18694 fail:
18695  return octave_value_list();
18696 }
18697 
18698 
18700  PLFLT *arg1 = (PLFLT *) 0 ;
18701  PLFLT *arg2 = (PLFLT *) 0 ;
18702  PLFLT *arg3 = (PLFLT *) 0 ;
18703  PLFLT *arg4 = (PLFLT *) 0 ;
18704  PLFLT temp1 ;
18705  int res1 = SWIG_TMPOBJ ;
18706  PLFLT temp2 ;
18707  int res2 = SWIG_TMPOBJ ;
18708  PLFLT temp3 ;
18709  int res3 = SWIG_TMPOBJ ;
18710  PLFLT temp4 ;
18711  int res4 = SWIG_TMPOBJ ;
18712  octave_value_list _out;
18713  octave_value_list *_outp=&_out;
18714  octave_value _outv;
18715 
18716  arg1 = &temp1;
18717  arg2 = &temp2;
18718  arg3 = &temp3;
18719  arg4 = &temp4;
18720  if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
18721  SWIG_fail;
18722  }
18723  plgvpd(arg1,arg2,arg3,arg4);
18724  _outv = octave_value();
18725  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18726  if (SWIG_IsTmpObj(res1)) {
18727  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18728  } else {
18729  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18730  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18731  }
18732  if (SWIG_IsTmpObj(res2)) {
18733  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18734  } else {
18735  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18736  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18737  }
18738  if (SWIG_IsTmpObj(res3)) {
18739  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18740  } else {
18741  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18742  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18743  }
18744  if (SWIG_IsTmpObj(res4)) {
18745  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18746  } else {
18747  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18748  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18749  }
18750  return _out;
18751 fail:
18752  return octave_value_list();
18753 }
18754 
18755 
18757  PLFLT *arg1 = (PLFLT *) 0 ;
18758  PLFLT *arg2 = (PLFLT *) 0 ;
18759  PLFLT *arg3 = (PLFLT *) 0 ;
18760  PLFLT *arg4 = (PLFLT *) 0 ;
18761  PLFLT temp1 ;
18762  int res1 = SWIG_TMPOBJ ;
18763  PLFLT temp2 ;
18764  int res2 = SWIG_TMPOBJ ;
18765  PLFLT temp3 ;
18766  int res3 = SWIG_TMPOBJ ;
18767  PLFLT temp4 ;
18768  int res4 = SWIG_TMPOBJ ;
18769  octave_value_list _out;
18770  octave_value_list *_outp=&_out;
18771  octave_value _outv;
18772 
18773  arg1 = &temp1;
18774  arg2 = &temp2;
18775  arg3 = &temp3;
18776  arg4 = &temp4;
18777  if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
18778  SWIG_fail;
18779  }
18780  plgvpw(arg1,arg2,arg3,arg4);
18781  _outv = octave_value();
18782  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18783  if (SWIG_IsTmpObj(res1)) {
18784  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18785  } else {
18786  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18787  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18788  }
18789  if (SWIG_IsTmpObj(res2)) {
18790  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18791  } else {
18792  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18793  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18794  }
18795  if (SWIG_IsTmpObj(res3)) {
18796  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18797  } else {
18798  int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18799  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18800  }
18801  if (SWIG_IsTmpObj(res4)) {
18802  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18803  } else {
18804  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18805  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18806  }
18807  return _out;
18808 fail:
18809  return octave_value_list();
18810 }
18811 
18812 
18814  PLINT *arg1 = (PLINT *) 0 ;
18815  PLINT *arg2 = (PLINT *) 0 ;
18816  PLINT temp1 ;
18817  int res1 = SWIG_TMPOBJ ;
18818  PLINT temp2 ;
18819  int res2 = SWIG_TMPOBJ ;
18820  octave_value_list _out;
18821  octave_value_list *_outp=&_out;
18822  octave_value _outv;
18823 
18824  arg1 = &temp1;
18825  arg2 = &temp2;
18826  if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
18827  SWIG_fail;
18828  }
18829  plgxax(arg1,arg2);
18830  _outv = octave_value();
18831  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18832  if (SWIG_IsTmpObj(res1)) {
18833  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18834  } else {
18835  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18836  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18837  }
18838  if (SWIG_IsTmpObj(res2)) {
18839  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18840  } else {
18841  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18842  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18843  }
18844  return _out;
18845 fail:
18846  return octave_value_list();
18847 }
18848 
18849 
18851  PLINT *arg1 = (PLINT *) 0 ;
18852  PLINT *arg2 = (PLINT *) 0 ;
18853  PLINT temp1 ;
18854  int res1 = SWIG_TMPOBJ ;
18855  PLINT temp2 ;
18856  int res2 = SWIG_TMPOBJ ;
18857  octave_value_list _out;
18858  octave_value_list *_outp=&_out;
18859  octave_value _outv;
18860 
18861  arg1 = &temp1;
18862  arg2 = &temp2;
18863  if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
18864  SWIG_fail;
18865  }
18866  plgyax(arg1,arg2);
18867  _outv = octave_value();
18868  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18869  if (SWIG_IsTmpObj(res1)) {
18870  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18871  } else {
18872  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18873  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18874  }
18875  if (SWIG_IsTmpObj(res2)) {
18876  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18877  } else {
18878  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18879  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18880  }
18881  return _out;
18882 fail:
18883  return octave_value_list();
18884 }
18885 
18886 
18888  PLINT *arg1 = (PLINT *) 0 ;
18889  PLINT *arg2 = (PLINT *) 0 ;
18890  PLINT temp1 ;
18891  int res1 = SWIG_TMPOBJ ;
18892  PLINT temp2 ;
18893  int res2 = SWIG_TMPOBJ ;
18894  octave_value_list _out;
18895  octave_value_list *_outp=&_out;
18896  octave_value _outv;
18897 
18898  arg1 = &temp1;
18899  arg2 = &temp2;
18900  if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
18901  SWIG_fail;
18902  }
18903  plgzax(arg1,arg2);
18904  _outv = octave_value();
18905  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18906  if (SWIG_IsTmpObj(res1)) {
18907  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18908  } else {
18909  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18910  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18911  }
18912  if (SWIG_IsTmpObj(res2)) {
18913  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18914  } else {
18915  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18916  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18917  }
18918  return _out;
18919 fail:
18920  return octave_value_list();
18921 }
18922 
18923 
18925  PLINT arg1 ;
18926  PLFLT *arg2 = (PLFLT *) 0 ;
18927  PLFLT arg3 ;
18928  PLFLT arg4 ;
18929  PLINT arg5 ;
18930  PLINT arg6 ;
18931  Matrix temp1 ;
18932  double val3 ;
18933  int ecode3 = 0 ;
18934  double val4 ;
18935  int ecode4 = 0 ;
18936  int val5 ;
18937  int ecode5 = 0 ;
18938  int val6 ;
18939  int ecode6 = 0 ;
18940  octave_value_list _out;
18941  octave_value_list *_outp=&_out;
18942  octave_value _outv;
18943 
18944  if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
18945  SWIG_fail;
18946  }
18947  {
18948  if ( _n_dims( args(0) ) > 1 )
18949  {
18950  error( "argument must be a scalar or vector" ); SWIG_fail;
18951  }
18952  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18953  temp1 = args(0).matrix_value();
18954  arg2 = &temp1( 0, 0 );
18955  }
18956  ecode3 = SWIG_AsVal_double(args(1), &val3);
18957  if (!SWIG_IsOK(ecode3)) {
18958  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
18959  }
18960  arg3 = static_cast< PLFLT >(val3);
18961  ecode4 = SWIG_AsVal_double(args(2), &val4);
18962  if (!SWIG_IsOK(ecode4)) {
18963  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
18964  }
18965  arg4 = static_cast< PLFLT >(val4);
18966  ecode5 = SWIG_AsVal_int(args(3), &val5);
18967  if (!SWIG_IsOK(ecode5)) {
18968  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
18969  }
18970  arg5 = static_cast< PLINT >(val5);
18971  ecode6 = SWIG_AsVal_int(args(4), &val6);
18972  if (!SWIG_IsOK(ecode6)) {
18973  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
18974  }
18975  arg6 = static_cast< PLINT >(val6);
18976  plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
18977  _outv = octave_value();
18978  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18979  {
18980 
18981  }
18982  return _out;
18983 fail:
18984  {
18985 
18986  }
18987  return octave_value_list();
18988 }
18989 
18990 
18992  PLFLT arg1 ;
18993  PLFLT arg2 ;
18994  PLFLT arg3 ;
18995  PLFLT *arg4 = (PLFLT *) 0 ;
18996  PLFLT *arg5 = (PLFLT *) 0 ;
18997  PLFLT *arg6 = (PLFLT *) 0 ;
18998  double val1 ;
18999  int ecode1 = 0 ;
19000  double val2 ;
19001  int ecode2 = 0 ;
19002  double val3 ;
19003  int ecode3 = 0 ;
19004  PLFLT temp4 ;
19005  int res4 = SWIG_TMPOBJ ;
19006  PLFLT temp5 ;
19007  int res5 = SWIG_TMPOBJ ;
19008  PLFLT temp6 ;
19009  int res6 = SWIG_TMPOBJ ;
19010  octave_value_list _out;
19011  octave_value_list *_outp=&_out;
19012  octave_value _outv;
19013 
19014  arg4 = &temp4;
19015  arg5 = &temp5;
19016  arg6 = &temp6;
19017  if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
19018  SWIG_fail;
19019  }
19020  ecode1 = SWIG_AsVal_double(args(0), &val1);
19021  if (!SWIG_IsOK(ecode1)) {
19022  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
19023  }
19024  arg1 = static_cast< PLFLT >(val1);
19025  ecode2 = SWIG_AsVal_double(args(1), &val2);
19026  if (!SWIG_IsOK(ecode2)) {
19027  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
19028  }
19029  arg2 = static_cast< PLFLT >(val2);
19030  ecode3 = SWIG_AsVal_double(args(2), &val3);
19031  if (!SWIG_IsOK(ecode3)) {
19032  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
19033  }
19034  arg3 = static_cast< PLFLT >(val3);
19035  plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
19036  _outv = octave_value();
19037  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19038  if (SWIG_IsTmpObj(res4)) {
19039  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19040  } else {
19041  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19042  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19043  }
19044  if (SWIG_IsTmpObj(res5)) {
19045  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19046  } else {
19047  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19048  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19049  }
19050  if (SWIG_IsTmpObj(res6)) {
19051  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
19052  } else {
19053  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19054  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
19055  }
19056  return _out;
19057 fail:
19058  return octave_value_list();
19059 }
19060 
19061 
19063  octave_value_list _out;
19064  octave_value_list *_outp=&_out;
19065  octave_value _outv;
19066 
19067  if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
19068  SWIG_fail;
19069  }
19070  plinit();
19071  _outv = octave_value();
19072  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19073  return _out;
19074 fail:
19075  return octave_value_list();
19076 }
19077 
19078 
19080  PLFLT arg1 ;
19081  PLFLT arg2 ;
19082  PLFLT arg3 ;
19083  PLFLT arg4 ;
19084  double val1 ;
19085  int ecode1 = 0 ;
19086  double val2 ;
19087  int ecode2 = 0 ;
19088  double val3 ;
19089  int ecode3 = 0 ;
19090  double val4 ;
19091  int ecode4 = 0 ;
19092  octave_value_list _out;
19093  octave_value_list *_outp=&_out;
19094  octave_value _outv;
19095 
19096  if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
19097  SWIG_fail;
19098  }
19099  ecode1 = SWIG_AsVal_double(args(0), &val1);
19100  if (!SWIG_IsOK(ecode1)) {
19101  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
19102  }
19103  arg1 = static_cast< PLFLT >(val1);
19104  ecode2 = SWIG_AsVal_double(args(1), &val2);
19105  if (!SWIG_IsOK(ecode2)) {
19106  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
19107  }
19108  arg2 = static_cast< PLFLT >(val2);
19109  ecode3 = SWIG_AsVal_double(args(2), &val3);
19110  if (!SWIG_IsOK(ecode3)) {
19111  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
19112  }
19113  arg3 = static_cast< PLFLT >(val3);
19114  ecode4 = SWIG_AsVal_double(args(3), &val4);
19115  if (!SWIG_IsOK(ecode4)) {
19116  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
19117  }
19118  arg4 = static_cast< PLFLT >(val4);
19119  pljoin(arg1,arg2,arg3,arg4);
19120  _outv = octave_value();
19121  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19122  return _out;
19123 fail:
19124  return octave_value_list();
19125 }
19126 
19127 
19129  char *arg1 = (char *) 0 ;
19130  char *arg2 = (char *) 0 ;
19131  char *arg3 = (char *) 0 ;
19132  int res1 ;
19133  char *buf1 = 0 ;
19134  int alloc1 = 0 ;
19135  int res2 ;
19136  char *buf2 = 0 ;
19137  int alloc2 = 0 ;
19138  int res3 ;
19139  char *buf3 = 0 ;
19140  int alloc3 = 0 ;
19141  octave_value_list _out;
19142  octave_value_list *_outp=&_out;
19143  octave_value _outv;
19144 
19145  if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
19146  SWIG_fail;
19147  }
19148  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19149  if (!SWIG_IsOK(res1)) {
19150  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
19151  }
19152  arg1 = reinterpret_cast< char * >(buf1);
19153  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
19154  if (!SWIG_IsOK(res2)) {
19155  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
19156  }
19157  arg2 = reinterpret_cast< char * >(buf2);
19158  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
19159  if (!SWIG_IsOK(res3)) {
19160  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
19161  }
19162  arg3 = reinterpret_cast< char * >(buf3);
19163  pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
19164  _outv = octave_value();
19165  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19166  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19167  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19168  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19169  return _out;
19170 fail:
19171  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19172  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19173  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19174  return octave_value_list();
19175 }
19176 
19177 
19179  PLFLT *arg1 = (PLFLT *) 0 ;
19180  PLFLT *arg2 = (PLFLT *) 0 ;
19181  PLINT arg3 ;
19182  PLINT arg4 ;
19183  PLFLT arg5 ;
19184  PLFLT arg6 ;
19185  PLFLT arg7 ;
19186  PLINT arg8 ;
19187  PLINT arg9 ;
19188  PLINT arg10 ;
19189  PLINT arg11 ;
19190  PLINT arg12 ;
19191  PLINT arg13 ;
19192  PLINT *arg14 = (PLINT *) 0 ;
19193  PLFLT arg15 ;
19194  PLFLT arg16 ;
19195  PLFLT arg17 ;
19196  PLFLT arg18 ;
19197  PLINT *arg19 = (PLINT *) 0 ;
19198  char **arg20 = (char **) 0 ;
19199  PLINT *arg21 = (PLINT *) 0 ;
19200  PLINT *arg22 = (PLINT *) 0 ;
19201  PLFLT *arg23 = (PLFLT *) 0 ;
19202  PLFLT *arg24 = (PLFLT *) 0 ;
19203  PLINT *arg25 = (PLINT *) 0 ;
19204  PLINT *arg26 = (PLINT *) 0 ;
19205  PLFLT *arg27 = (PLFLT *) 0 ;
19206  PLINT *arg28 = (PLINT *) 0 ;
19207  PLFLT *arg29 = (PLFLT *) 0 ;
19208  PLINT *arg30 = (PLINT *) 0 ;
19209  char **arg31 = (char **) 0 ;
19210  PLFLT temp1 ;
19211  int res1 = SWIG_TMPOBJ ;
19212  PLFLT temp2 ;
19213  int res2 = SWIG_TMPOBJ ;
19214  int val3 ;
19215  int ecode3 = 0 ;
19216  int val4 ;
19217  int ecode4 = 0 ;
19218  double val5 ;
19219  int ecode5 = 0 ;
19220  double val6 ;
19221  int ecode6 = 0 ;
19222  double val7 ;
19223  int ecode7 = 0 ;
19224  int val8 ;
19225  int ecode8 = 0 ;
19226  int val9 ;
19227  int ecode9 = 0 ;
19228  int val10 ;
19229  int ecode10 = 0 ;
19230  int val11 ;
19231  int ecode11 = 0 ;
19232  int val12 ;
19233  int ecode12 = 0 ;
19234  Matrix temp13 ;
19235  double val15 ;
19236  int ecode15 = 0 ;
19237  double val16 ;
19238  int ecode16 = 0 ;
19239  double val17 ;
19240  int ecode17 = 0 ;
19241  double val18 ;
19242  int ecode18 = 0 ;
19243  Matrix temp19 ;
19244  Matrix temp21 ;
19245  Matrix temp22 ;
19246  Matrix temp23 ;
19247  Matrix temp24 ;
19248  Matrix temp25 ;
19249  Matrix temp26 ;
19250  Matrix temp27 ;
19251  Matrix temp28 ;
19252  Matrix temp29 ;
19253  Matrix temp30 ;
19254  octave_value_list _out;
19255  octave_value_list *_outp=&_out;
19256  octave_value _outv;
19257 
19258  arg1 = &temp1;
19259  arg2 = &temp2;
19260  if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
19261  SWIG_fail;
19262  }
19263  ecode3 = SWIG_AsVal_int(args(0), &val3);
19264  if (!SWIG_IsOK(ecode3)) {
19265  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
19266  }
19267  arg3 = static_cast< PLINT >(val3);
19268  ecode4 = SWIG_AsVal_int(args(1), &val4);
19269  if (!SWIG_IsOK(ecode4)) {
19270  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
19271  }
19272  arg4 = static_cast< PLINT >(val4);
19273  ecode5 = SWIG_AsVal_double(args(2), &val5);
19274  if (!SWIG_IsOK(ecode5)) {
19275  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
19276  }
19277  arg5 = static_cast< PLFLT >(val5);
19278  ecode6 = SWIG_AsVal_double(args(3), &val6);
19279  if (!SWIG_IsOK(ecode6)) {
19280  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
19281  }
19282  arg6 = static_cast< PLFLT >(val6);
19283  ecode7 = SWIG_AsVal_double(args(4), &val7);
19284  if (!SWIG_IsOK(ecode7)) {
19285  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
19286  }
19287  arg7 = static_cast< PLFLT >(val7);
19288  ecode8 = SWIG_AsVal_int(args(5), &val8);
19289  if (!SWIG_IsOK(ecode8)) {
19290  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
19291  }
19292  arg8 = static_cast< PLINT >(val8);
19293  ecode9 = SWIG_AsVal_int(args(6), &val9);
19294  if (!SWIG_IsOK(ecode9)) {
19295  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
19296  }
19297  arg9 = static_cast< PLINT >(val9);
19298  ecode10 = SWIG_AsVal_int(args(7), &val10);
19299  if (!SWIG_IsOK(ecode10)) {
19300  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
19301  }
19302  arg10 = static_cast< PLINT >(val10);
19303  ecode11 = SWIG_AsVal_int(args(8), &val11);
19304  if (!SWIG_IsOK(ecode11)) {
19305  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
19306  }
19307  arg11 = static_cast< PLINT >(val11);
19308  ecode12 = SWIG_AsVal_int(args(9), &val12);
19309  if (!SWIG_IsOK(ecode12)) {
19310  SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
19311  }
19312  arg12 = static_cast< PLINT >(val12);
19313  {
19314  if ( _n_dims( args(10) ) > 1 )
19315  {
19316  error( "argument must be a scalar or vector" ); SWIG_fail;
19317  }
19318  arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
19319  arg14 = new PLINT[Alen];
19320  temp13 = args(10).matrix_value();
19321  _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
19322  }
19323  ecode15 = SWIG_AsVal_double(args(11), &val15);
19324  if (!SWIG_IsOK(ecode15)) {
19325  SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
19326  }
19327  arg15 = static_cast< PLFLT >(val15);
19328  ecode16 = SWIG_AsVal_double(args(12), &val16);
19329  if (!SWIG_IsOK(ecode16)) {
19330  SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
19331  }
19332  arg16 = static_cast< PLFLT >(val16);
19333  ecode17 = SWIG_AsVal_double(args(13), &val17);
19334  if (!SWIG_IsOK(ecode17)) {
19335  SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
19336  }
19337  arg17 = static_cast< PLFLT >(val17);
19338  ecode18 = SWIG_AsVal_double(args(14), &val18);
19339  if (!SWIG_IsOK(ecode18)) {
19340  SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
19341  }
19342  arg18 = static_cast< PLFLT >(val18);
19343  {
19344  if ( _n_dims( args(15) ) > 1 )
19345  {
19346  error( "argument must be a scalar or vector" ); SWIG_fail;
19347  }
19348  if ( _dim( args(15), 0 ) != Alen )
19349  {
19350  error( "argument vectors must be same length" ); SWIG_fail;
19351  }
19352  temp19 = args(15).matrix_value();
19353  arg19 = new PLINT[Alen];
19354  _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
19355  }
19356  {
19357  charMatrix temp_matrix;
19358  Cell temp_cell;
19359  char *tmp_cstring;
19360  std::string str;
19361  size_t max_length = 0, non_blank_length;
19362  int i, ifcell;
19363  if ( _n_dims( args(16) ) > 2 )
19364  {
19365  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
19366  }
19367 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19368  if ( !args(16).isempty() )
19369 #else
19370  if ( !args(16).is_empty() )
19371 #endif
19372  {
19373  if ( _dim( args(16), 0 ) != Alen )
19374  {
19375  error( "first dimension must be same length as previous vector" ); SWIG_fail;
19376  }
19377  arg20 = new char*[Alen];
19378 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19379  ifcell = args(16).iscell();
19380 #else
19381  ifcell = args(16).is_cell();
19382 #endif
19383  if ( ifcell )
19384  {
19385  temp_cell = args(16).cell_value();
19386  }
19387  else
19388  {
19389  temp_matrix = args(16).char_matrix_value();
19390  // Allow one extra space for null termination.
19391  max_length = _dim( args(16), 1 ) + 1;
19392  }
19393 
19394  for ( i = 0; i < Alen; i++ )
19395  {
19396  // Must copy string to "permanent" location because the string
19397  // location corresponding to tmp_cstring gets
19398  // overwritten for each iteration of loop.
19399  if ( ifcell )
19400  {
19401  if ( temp_cell.elem( i ).is_string() )
19402  {
19403  str = temp_cell.elem( i ).string_value();
19404  // leave room for null termination.
19405  max_length = str.size() + 1;
19406  tmp_cstring = (char *) str.c_str();
19407  }
19408  else
19409  {
19410  // Use null string if user attempts to pass a cell array
19411  // with a non-string element (likely an empty element
19412  // since that should be allowed by the PLplot interface
19413  // if that element is going to be unused).
19414  // leave room for null termination.
19415  max_length = 1;
19416  tmp_cstring = (char *) "";
19417  }
19418  }
19419  else
19420  {
19421  str = temp_matrix.row_as_string( i );
19422  tmp_cstring = (char *) str.c_str();
19423  }
19424  arg20[i] = new char[max_length];
19425  strncpy( arg20[i], tmp_cstring, max_length - 1 );
19426  arg20[i][max_length - 1] = '\0';
19427  // All the trailing blank crapola should not be needed for
19428  // string cell arrays.
19429  if ( !ifcell )
19430  {
19431  // remove trailing-blank padding that is used by the
19432  // charMatrix class to insure all strings in a given
19433  // charMatrix instance have the same length.
19434  // This transformation also removes legitimate trailing
19435  // blanks but there is nothing we can do about that
19436  // for the charMatrix class.
19437 
19438  // Look for trailing nulls first (just in case, although that
19439  // shouldn't happen if charMatrix implemented as documented)
19440  // before looking for trailing blanks.
19441  non_blank_length = max_length - 2;
19442  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
19443  {
19444  non_blank_length--;
19445  }
19446  while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
19447  {
19448  non_blank_length--;
19449  }
19450  arg20[i][non_blank_length + 1] = '\0';
19451  }
19452  }
19453  }
19454  else
19455  {
19456  arg20 = NULL;
19457  }
19458  }
19459  {
19460  if ( _n_dims( args(17) ) > 1 )
19461  {
19462  error( "argument must be a scalar or vector" ); SWIG_fail;
19463  }
19464 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19465  if ( !args(17).isempty() )
19466 #else
19467  if ( !args(17).is_empty() )
19468 #endif
19469  {
19470  if ( _dim( args(17), 0 ) != Alen )
19471  {
19472  error( "argument vectors must be same length" ); SWIG_fail;
19473  }
19474  temp21 = args(17).matrix_value();
19475  arg21 = new PLINT[Alen];
19476  _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
19477  }
19478  else
19479  {
19480  arg21 = NULL;
19481  }
19482  }
19483  {
19484  if ( _n_dims( args(18) ) > 1 )
19485  {
19486  error( "argument must be a scalar or vector" ); SWIG_fail;
19487  }
19488 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19489  if ( !args(18).isempty() )
19490 #else
19491  if ( !args(18).is_empty() )
19492 #endif
19493  {
19494  if ( _dim( args(18), 0 ) != Alen )
19495  {
19496  error( "argument vectors must be same length" ); SWIG_fail;
19497  }
19498  temp22 = args(18).matrix_value();
19499  arg22 = new PLINT[Alen];
19500  _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
19501  }
19502  else
19503  {
19504  arg22 = NULL;
19505  }
19506  }
19507  {
19508  if ( _n_dims( args(19) ) > 1 )
19509  {
19510  error( "argument must be a scalar or vector" ); SWIG_fail;
19511  }
19512 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19513  if ( !args(19).isempty() )
19514 #else
19515  if ( !args(19).is_empty() )
19516 #endif
19517  {
19518  if ( _dim( args(19), 0 ) != Alen )
19519  {
19520  error( "argument vectors must be same length" ); SWIG_fail;
19521  }
19522  temp23 = args(19).matrix_value();
19523  arg23 = &temp23( 0, 0 );
19524  }
19525  else
19526  {
19527  arg23 = NULL;
19528  }
19529  }
19530  {
19531  if ( _n_dims( args(20) ) > 1 )
19532  {
19533  error( "argument must be a scalar or vector" ); SWIG_fail;
19534  }
19535 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19536  if ( !args(20).isempty() )
19537 #else
19538  if ( !args(20).is_empty() )
19539 #endif
19540  {
19541  if ( _dim( args(20), 0 ) != Alen )
19542  {
19543  error( "argument vectors must be same length" ); SWIG_fail;
19544  }
19545  temp24 = args(20).matrix_value();
19546  arg24 = &temp24( 0, 0 );
19547  }
19548  else
19549  {
19550  arg24 = NULL;
19551  }
19552  }
19553  {
19554  if ( _n_dims( args(21) ) > 1 )
19555  {
19556  error( "argument must be a scalar or vector" ); SWIG_fail;
19557  }
19558 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19559  if ( !args(21).isempty() )
19560 #else
19561  if ( !args(21).is_empty() )
19562 #endif
19563  {
19564  if ( _dim( args(21), 0 ) != Alen )
19565  {
19566  error( "argument vectors must be same length" ); SWIG_fail;
19567  }
19568  temp25 = args(21).matrix_value();
19569  arg25 = new PLINT[Alen];
19570  _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
19571  }
19572  else
19573  {
19574  arg25 = NULL;
19575  }
19576  }
19577  {
19578  if ( _n_dims( args(22) ) > 1 )
19579  {
19580  error( "argument must be a scalar or vector" ); SWIG_fail;
19581  }
19582 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19583  if ( !args(22).isempty() )
19584 #else
19585  if ( !args(22).is_empty() )
19586 #endif
19587  {
19588  if ( _dim( args(22), 0 ) != Alen )
19589  {
19590  error( "argument vectors must be same length" ); SWIG_fail;
19591  }
19592  temp26 = args(22).matrix_value();
19593  arg26 = new PLINT[Alen];
19594  _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
19595  }
19596  else
19597  {
19598  arg26 = NULL;
19599  }
19600  }
19601  {
19602  if ( _n_dims( args(23) ) > 1 )
19603  {
19604  error( "argument must be a scalar or vector" ); SWIG_fail;
19605  }
19606 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19607  if ( !args(23).isempty() )
19608 #else
19609  if ( !args(23).is_empty() )
19610 #endif
19611  {
19612  if ( _dim( args(23), 0 ) != Alen )
19613  {
19614  error( "argument vectors must be same length" ); SWIG_fail;
19615  }
19616  temp27 = args(23).matrix_value();
19617  arg27 = &temp27( 0, 0 );
19618  }
19619  else
19620  {
19621  arg27 = NULL;
19622  }
19623  }
19624  {
19625  if ( _n_dims( args(24) ) > 1 )
19626  {
19627  error( "argument must be a scalar or vector" ); SWIG_fail;
19628  }
19629 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19630  if ( !args(24).isempty() )
19631 #else
19632  if ( !args(24).is_empty() )
19633 #endif
19634  {
19635  if ( _dim( args(24), 0 ) != Alen )
19636  {
19637  error( "argument vectors must be same length" ); SWIG_fail;
19638  }
19639  temp28 = args(24).matrix_value();
19640  arg28 = new PLINT[Alen];
19641  _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
19642  }
19643  else
19644  {
19645  arg28 = NULL;
19646  }
19647  }
19648  {
19649  if ( _n_dims( args(25) ) > 1 )
19650  {
19651  error( "argument must be a scalar or vector" ); SWIG_fail;
19652  }
19653 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19654  if ( !args(25).isempty() )
19655 #else
19656  if ( !args(25).is_empty() )
19657 #endif
19658  {
19659  if ( _dim( args(25), 0 ) != Alen )
19660  {
19661  error( "argument vectors must be same length" ); SWIG_fail;
19662  }
19663  temp29 = args(25).matrix_value();
19664  arg29 = &temp29( 0, 0 );
19665  }
19666  else
19667  {
19668  arg29 = NULL;
19669  }
19670  }
19671  {
19672  if ( _n_dims( args(26) ) > 1 )
19673  {
19674  error( "argument must be a scalar or vector" ); SWIG_fail;
19675  }
19676 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19677  if ( !args(26).isempty() )
19678 #else
19679  if ( !args(26).is_empty() )
19680 #endif
19681  {
19682  if ( _dim( args(26), 0 ) != Alen )
19683  {
19684  error( "argument vectors must be same length" ); SWIG_fail;
19685  }
19686  temp30 = args(26).matrix_value();
19687  arg30 = new PLINT[Alen];
19688  _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
19689  }
19690  else
19691  {
19692  arg30 = NULL;
19693  }
19694  }
19695  {
19696  charMatrix temp_matrix;
19697  Cell temp_cell;
19698  char *tmp_cstring;
19699  std::string str;
19700  size_t max_length = 0, non_blank_length;
19701  int i, ifcell;
19702  if ( _n_dims( args(27) ) > 2 )
19703  {
19704  error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
19705  }
19706 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19707  if ( !args(27).isempty() )
19708 #else
19709  if ( !args(27).is_empty() )
19710 #endif
19711  {
19712  if ( _dim( args(27), 0 ) != Alen )
19713  {
19714  error( "first dimension must be same length as previous vector" ); SWIG_fail;
19715  }
19716  arg31 = new char*[Alen];
19717 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19718  ifcell = args(27).iscell();
19719 #else
19720  ifcell = args(27).is_cell();
19721 #endif
19722  if ( ifcell )
19723  {
19724  temp_cell = args(27).cell_value();
19725  }
19726  else
19727  {
19728  temp_matrix = args(27).char_matrix_value();
19729  // Allow one extra space for null termination.
19730  max_length = _dim( args(27), 1 ) + 1;
19731  }
19732 
19733  for ( i = 0; i < Alen; i++ )
19734  {
19735  // Must copy string to "permanent" location because the string
19736  // location corresponding to tmp_cstring gets
19737  // overwritten for each iteration of loop.
19738  if ( ifcell )
19739  {
19740  if ( temp_cell.elem( i ).is_string() )
19741  {
19742  str = temp_cell.elem( i ).string_value();
19743  // leave room for null termination.
19744  max_length = str.size() + 1;
19745  tmp_cstring = (char *) str.c_str();
19746  }
19747  else
19748  {
19749  // Use null string if user attempts to pass a cell array
19750  // with a non-string element (likely an empty element
19751  // since that should be allowed by the PLplot interface
19752  // if that element is going to be unused).
19753  // leave room for null termination.
19754  max_length = 1;
19755  tmp_cstring = (char *) "";
19756  }
19757  }
19758  else
19759  {
19760  str = temp_matrix.row_as_string( i );
19761  tmp_cstring = (char *) str.c_str();
19762  }
19763  arg31[i] = new char[max_length];
19764  strncpy( arg31[i], tmp_cstring, max_length - 1 );
19765  arg31[i][max_length - 1] = '\0';
19766  // All the trailing blank crapola should not be needed for
19767  // string cell arrays.
19768  if ( !ifcell )
19769  {
19770  // remove trailing-blank padding that is used by the
19771  // charMatrix class to insure all strings in a given
19772  // charMatrix instance have the same length.
19773  // This transformation also removes legitimate trailing
19774  // blanks but there is nothing we can do about that
19775  // for the charMatrix class.
19776 
19777  // Look for trailing nulls first (just in case, although that
19778  // shouldn't happen if charMatrix implemented as documented)
19779  // before looking for trailing blanks.
19780  non_blank_length = max_length - 2;
19781  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
19782  {
19783  non_blank_length--;
19784  }
19785  while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
19786  {
19787  non_blank_length--;
19788  }
19789  arg31[i][non_blank_length + 1] = '\0';
19790  }
19791  }
19792  }
19793  else
19794  {
19795  arg31 = NULL;
19796  }
19797  }
19798  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);
19799  _outv = octave_value();
19800  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19801  if (SWIG_IsTmpObj(res1)) {
19802  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19803  } else {
19804  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19805  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19806  }
19807  if (SWIG_IsTmpObj(res2)) {
19808  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19809  } else {
19810  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19811  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19812  }
19813  {
19814  delete [] arg14;
19815  }
19816  {
19817  delete [] arg19;
19818  }
19819  {
19820  int i;
19821  if ( arg20 != NULL )
19822  {
19823  for ( i = 0; i < Alen; i++ )
19824  {
19825  delete[] arg20[i];
19826  }
19827  delete[] arg20;
19828  }
19829  }
19830  {
19831  if ( arg21 != NULL )
19832  delete [] arg21;
19833  }
19834  {
19835  if ( arg22 != NULL )
19836  delete [] arg22;
19837  }
19838  {
19839 
19840  }
19841  {
19842 
19843  }
19844  {
19845  if ( arg25 != NULL )
19846  delete [] arg25;
19847  }
19848  {
19849  if ( arg26 != NULL )
19850  delete [] arg26;
19851  }
19852  {
19853 
19854  }
19855  {
19856  if ( arg28 != NULL )
19857  delete [] arg28;
19858  }
19859  {
19860 
19861  }
19862  {
19863  if ( arg30 != NULL )
19864  delete [] arg30;
19865  }
19866  {
19867  int i;
19868  if ( arg31 != NULL )
19869  {
19870  for ( i = 0; i < Alen; i++ )
19871  {
19872  delete[] arg31[i];
19873  }
19874  delete[] arg31;
19875  }
19876  }
19877  return _out;
19878 fail:
19879  {
19880  delete [] arg14;
19881  }
19882  {
19883  delete [] arg19;
19884  }
19885  {
19886  int i;
19887  if ( arg20 != NULL )
19888  {
19889  for ( i = 0; i < Alen; i++ )
19890  {
19891  delete[] arg20[i];
19892  }
19893  delete[] arg20;
19894  }
19895  }
19896  {
19897  if ( arg21 != NULL )
19898  delete [] arg21;
19899  }
19900  {
19901  if ( arg22 != NULL )
19902  delete [] arg22;
19903  }
19904  {
19905 
19906  }
19907  {
19908 
19909  }
19910  {
19911  if ( arg25 != NULL )
19912  delete [] arg25;
19913  }
19914  {
19915  if ( arg26 != NULL )
19916  delete [] arg26;
19917  }
19918  {
19919 
19920  }
19921  {
19922  if ( arg28 != NULL )
19923  delete [] arg28;
19924  }
19925  {
19926 
19927  }
19928  {
19929  if ( arg30 != NULL )
19930  delete [] arg30;
19931  }
19932  {
19933  int i;
19934  if ( arg31 != NULL )
19935  {
19936  for ( i = 0; i < Alen; i++ )
19937  {
19938  delete[] arg31[i];
19939  }
19940  delete[] arg31;
19941  }
19942  }
19943  return octave_value_list();
19944 }
19945 
19946 
19948  PLFLT arg1 ;
19949  PLFLT arg2 ;
19950  PLFLT arg3 ;
19951  double val1 ;
19952  int ecode1 = 0 ;
19953  double val2 ;
19954  int ecode2 = 0 ;
19955  double val3 ;
19956  int ecode3 = 0 ;
19957  octave_value_list _out;
19958  octave_value_list *_outp=&_out;
19959  octave_value _outv;
19960 
19961  if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
19962  SWIG_fail;
19963  }
19964  ecode1 = SWIG_AsVal_double(args(0), &val1);
19965  if (!SWIG_IsOK(ecode1)) {
19966  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
19967  }
19968  arg1 = static_cast< PLFLT >(val1);
19969  ecode2 = SWIG_AsVal_double(args(1), &val2);
19970  if (!SWIG_IsOK(ecode2)) {
19971  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
19972  }
19973  arg2 = static_cast< PLFLT >(val2);
19974  ecode3 = SWIG_AsVal_double(args(2), &val3);
19975  if (!SWIG_IsOK(ecode3)) {
19976  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
19977  }
19978  arg3 = static_cast< PLFLT >(val3);
19979  pllightsource(arg1,arg2,arg3);
19980  _outv = octave_value();
19981  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19982  return _out;
19983 fail:
19984  return octave_value_list();
19985 }
19986 
19987 
19989  PLINT arg1 ;
19990  PLFLT *arg2 = (PLFLT *) 0 ;
19991  PLFLT *arg3 = (PLFLT *) 0 ;
19992  Matrix temp1 ;
19993  Matrix temp3 ;
19994  octave_value_list _out;
19995  octave_value_list *_outp=&_out;
19996  octave_value _outv;
19997 
19998  if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
19999  SWIG_fail;
20000  }
20001  {
20002  if ( _n_dims( args(0) ) > 1 )
20003  {
20004  error( "argument must be a scalar or vector" ); SWIG_fail;
20005  }
20006  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20007  temp1 = args(0).matrix_value();
20008  arg2 = &temp1( 0, 0 );
20009  }
20010  {
20011  if ( _n_dims( args(1) ) > 1 )
20012  {
20013  error( "argument must be a scalar or vector" ); SWIG_fail;
20014  }
20015  if ( _dim( args(1), 0 ) != Alen )
20016  {
20017  error( "argument vectors must be same length" ); SWIG_fail;
20018  }
20019  temp3 = args(1).matrix_value();
20020  arg3 = &temp3( 0, 0 );
20021  }
20022  plline(arg1,(double const *)arg2,(double const *)arg3);
20023  _outv = octave_value();
20024  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20025  {
20026 
20027  }
20028  {
20029 
20030  }
20031  return _out;
20032 fail:
20033  {
20034 
20035  }
20036  {
20037 
20038  }
20039  return octave_value_list();
20040 }
20041 
20042 
20044  PLINT arg1 ;
20045  PLFLT *arg2 = (PLFLT *) 0 ;
20046  PLFLT *arg3 = (PLFLT *) 0 ;
20047  PLFLT *arg4 = (PLFLT *) 0 ;
20048  Matrix temp1 ;
20049  Matrix temp3 ;
20050  Matrix temp4 ;
20051  octave_value_list _out;
20052  octave_value_list *_outp=&_out;
20053  octave_value _outv;
20054 
20055  if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
20056  SWIG_fail;
20057  }
20058  {
20059  if ( _n_dims( args(0) ) > 1 )
20060  {
20061  error( "argument must be a scalar or vector" ); SWIG_fail;
20062  }
20063  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20064  temp1 = args(0).matrix_value();
20065  arg2 = &temp1( 0, 0 );
20066  }
20067  {
20068  if ( _n_dims( args(1) ) > 1 )
20069  {
20070  error( "argument must be a scalar or vector" ); SWIG_fail;
20071  }
20072  if ( _dim( args(1), 0 ) != Alen )
20073  {
20074  error( "argument vectors must be same length" ); SWIG_fail;
20075  }
20076  temp3 = args(1).matrix_value();
20077  arg3 = &temp3( 0, 0 );
20078  }
20079  {
20080  if ( _n_dims( args(2) ) > 1 )
20081  {
20082  error( "argument must be a scalar or vector" ); SWIG_fail;
20083  }
20084  if ( _dim( args(2), 0 ) != Alen )
20085  {
20086  error( "argument vectors must be same length" ); SWIG_fail;
20087  }
20088  temp4 = args(2).matrix_value();
20089  arg4 = &temp4( 0, 0 );
20090  }
20091  plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
20092  _outv = octave_value();
20093  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20094  {
20095 
20096  }
20097  {
20098 
20099  }
20100  {
20101 
20102  }
20103  return _out;
20104 fail:
20105  {
20106 
20107  }
20108  {
20109 
20110  }
20111  {
20112 
20113  }
20114  return octave_value_list();
20115 }
20116 
20117 
20119  PLINT arg1 ;
20120  int val1 ;
20121  int ecode1 = 0 ;
20122  octave_value_list _out;
20123  octave_value_list *_outp=&_out;
20124  octave_value _outv;
20125 
20126  if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
20127  SWIG_fail;
20128  }
20129  ecode1 = SWIG_AsVal_int(args(0), &val1);
20130  if (!SWIG_IsOK(ecode1)) {
20131  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
20132  }
20133  arg1 = static_cast< PLINT >(val1);
20134  pllsty(arg1);
20135  _outv = octave_value();
20136  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20137  return _out;
20138 fail:
20139  return octave_value_list();
20140 }
20141 
20142 
20144  PLINT *arg1 = (PLINT *) 0 ;
20145  PLINT temp1 ;
20146  int res1 = SWIG_TMPOBJ ;
20147  octave_value_list _out;
20148  octave_value_list *_outp=&_out;
20149  octave_value _outv;
20150 
20151  arg1 = &temp1;
20152  if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
20153  SWIG_fail;
20154  }
20155  plmkstrm(arg1);
20156  _outv = octave_value();
20157  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20158  if (SWIG_IsTmpObj(res1)) {
20159  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20160  } else {
20161  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20162  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20163  }
20164  return _out;
20165 fail:
20166  return octave_value_list();
20167 }
20168 
20169 
20171  char *arg1 = (char *) 0 ;
20172  PLFLT arg2 ;
20173  PLFLT arg3 ;
20174  PLFLT arg4 ;
20175  char *arg5 = (char *) 0 ;
20176  int res1 ;
20177  char *buf1 = 0 ;
20178  int alloc1 = 0 ;
20179  double val2 ;
20180  int ecode2 = 0 ;
20181  double val3 ;
20182  int ecode3 = 0 ;
20183  double val4 ;
20184  int ecode4 = 0 ;
20185  int res5 ;
20186  char *buf5 = 0 ;
20187  int alloc5 = 0 ;
20188  octave_value_list _out;
20189  octave_value_list *_outp=&_out;
20190  octave_value _outv;
20191 
20192  if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
20193  SWIG_fail;
20194  }
20195  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20196  if (!SWIG_IsOK(res1)) {
20197  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
20198  }
20199  arg1 = reinterpret_cast< char * >(buf1);
20200  ecode2 = SWIG_AsVal_double(args(1), &val2);
20201  if (!SWIG_IsOK(ecode2)) {
20202  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
20203  }
20204  arg2 = static_cast< PLFLT >(val2);
20205  ecode3 = SWIG_AsVal_double(args(2), &val3);
20206  if (!SWIG_IsOK(ecode3)) {
20207  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
20208  }
20209  arg3 = static_cast< PLFLT >(val3);
20210  ecode4 = SWIG_AsVal_double(args(3), &val4);
20211  if (!SWIG_IsOK(ecode4)) {
20212  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
20213  }
20214  arg4 = static_cast< PLFLT >(val4);
20215  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
20216  if (!SWIG_IsOK(res5)) {
20217  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
20218  }
20219  arg5 = reinterpret_cast< char * >(buf5);
20220  plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
20221  _outv = octave_value();
20222  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20223  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20224  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20225  return _out;
20226 fail:
20227  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20228  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20229  return octave_value_list();
20230 }
20231 
20232 
20234  char *arg1 = (char *) 0 ;
20235  PLFLT arg2 ;
20236  PLFLT arg3 ;
20237  PLFLT arg4 ;
20238  char *arg5 = (char *) 0 ;
20239  int res1 ;
20240  char *buf1 = 0 ;
20241  int alloc1 = 0 ;
20242  double val2 ;
20243  int ecode2 = 0 ;
20244  double val3 ;
20245  int ecode3 = 0 ;
20246  double val4 ;
20247  int ecode4 = 0 ;
20248  int res5 ;
20249  char *buf5 = 0 ;
20250  int alloc5 = 0 ;
20251  octave_value_list _out;
20252  octave_value_list *_outp=&_out;
20253  octave_value _outv;
20254 
20255  if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
20256  SWIG_fail;
20257  }
20258  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20259  if (!SWIG_IsOK(res1)) {
20260  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
20261  }
20262  arg1 = reinterpret_cast< char * >(buf1);
20263  ecode2 = SWIG_AsVal_double(args(1), &val2);
20264  if (!SWIG_IsOK(ecode2)) {
20265  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
20266  }
20267  arg2 = static_cast< PLFLT >(val2);
20268  ecode3 = SWIG_AsVal_double(args(2), &val3);
20269  if (!SWIG_IsOK(ecode3)) {
20270  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
20271  }
20272  arg3 = static_cast< PLFLT >(val3);
20273  ecode4 = SWIG_AsVal_double(args(3), &val4);
20274  if (!SWIG_IsOK(ecode4)) {
20275  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
20276  }
20277  arg4 = static_cast< PLFLT >(val4);
20278  res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
20279  if (!SWIG_IsOK(res5)) {
20280  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
20281  }
20282  arg5 = reinterpret_cast< char * >(buf5);
20283  plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
20284  _outv = octave_value();
20285  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20286  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20287  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20288  return _out;
20289 fail:
20290  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20291  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20292  return octave_value_list();
20293 }
20294 
20295 
20297  int *arg1 = (int *) 0 ;
20298  char **arg2 = (char **) 0 ;
20299  PLINT arg3 ;
20300  void *argp1 = 0 ;
20301  int res1 = 0 ;
20302  void *argp2 = 0 ;
20303  int res2 = 0 ;
20304  int val3 ;
20305  int ecode3 = 0 ;
20306  octave_value_list _out;
20307  octave_value_list *_outp=&_out;
20308  octave_value _outv;
20309  PLINT result;
20310 
20311  if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
20312  SWIG_fail;
20313  }
20314  res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
20315  if (!SWIG_IsOK(res1)) {
20316  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
20317  }
20318  arg1 = reinterpret_cast< int * >(argp1);
20319  res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
20320  if (!SWIG_IsOK(res2)) {
20321  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
20322  }
20323  arg2 = reinterpret_cast< char ** >(argp2);
20324  ecode3 = SWIG_AsVal_int(args(2), &val3);
20325  if (!SWIG_IsOK(ecode3)) {
20326  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
20327  }
20328  arg3 = static_cast< PLINT >(val3);
20329  result = (PLINT)plparseopts(arg1,arg2,arg3);
20330  _outv = SWIG_From_int(static_cast< int >(result));
20331  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20332  return _out;
20333 fail:
20334  return octave_value_list();
20335 }
20336 
20337 
20339  PLINT arg1 ;
20340  PLINT *arg2 = (PLINT *) 0 ;
20341  PLINT *arg3 = (PLINT *) 0 ;
20342  Matrix temp1 ;
20343  Matrix temp3 ;
20344  octave_value_list _out;
20345  octave_value_list *_outp=&_out;
20346  octave_value _outv;
20347 
20348  if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
20349  SWIG_fail;
20350  }
20351  {
20352  if ( _n_dims( args(0) ) > 1 )
20353  {
20354  error( "argument must be a scalar or vector" ); SWIG_fail;
20355  }
20356  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20357  arg2 = new PLINT[Alen];
20358  temp1 = args(0).matrix_value();
20359  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
20360  }
20361  {
20362  if ( _n_dims( args(1) ) > 1 )
20363  {
20364  error( "argument must be a scalar or vector" ); SWIG_fail;
20365  }
20366  if ( _dim( args(1), 0 ) != Alen )
20367  {
20368  error( "argument vectors must be same length" ); SWIG_fail;
20369  }
20370  temp3 = args(1).matrix_value();
20371  arg3 = new PLINT[Alen];
20372  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
20373  }
20374  plpat(arg1,(int const *)arg2,(int const *)arg3);
20375  _outv = octave_value();
20376  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20377  {
20378  delete [] arg2;
20379  }
20380  {
20381  delete [] arg3;
20382  }
20383  return _out;
20384 fail:
20385  {
20386  delete [] arg2;
20387  }
20388  {
20389  delete [] arg3;
20390  }
20391  return octave_value_list();
20392 }
20393 
20394 
20396  PLINT arg1 ;
20397  PLFLT arg2 ;
20398  PLFLT arg3 ;
20399  PLFLT arg4 ;
20400  PLFLT arg5 ;
20401  int val1 ;
20402  int ecode1 = 0 ;
20403  double val2 ;
20404  int ecode2 = 0 ;
20405  double val3 ;
20406  int ecode3 = 0 ;
20407  double val4 ;
20408  int ecode4 = 0 ;
20409  double val5 ;
20410  int ecode5 = 0 ;
20411  octave_value_list _out;
20412  octave_value_list *_outp=&_out;
20413  octave_value _outv;
20414 
20415  if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
20416  SWIG_fail;
20417  }
20418  ecode1 = SWIG_AsVal_int(args(0), &val1);
20419  if (!SWIG_IsOK(ecode1)) {
20420  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
20421  }
20422  arg1 = static_cast< PLINT >(val1);
20423  ecode2 = SWIG_AsVal_double(args(1), &val2);
20424  if (!SWIG_IsOK(ecode2)) {
20425  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
20426  }
20427  arg2 = static_cast< PLFLT >(val2);
20428  ecode3 = SWIG_AsVal_double(args(2), &val3);
20429  if (!SWIG_IsOK(ecode3)) {
20430  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
20431  }
20432  arg3 = static_cast< PLFLT >(val3);
20433  ecode4 = SWIG_AsVal_double(args(3), &val4);
20434  if (!SWIG_IsOK(ecode4)) {
20435  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
20436  }
20437  arg4 = static_cast< PLFLT >(val4);
20438  ecode5 = SWIG_AsVal_double(args(4), &val5);
20439  if (!SWIG_IsOK(ecode5)) {
20440  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
20441  }
20442  arg5 = static_cast< PLFLT >(val5);
20443  plpath(arg1,arg2,arg3,arg4,arg5);
20444  _outv = octave_value();
20445  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20446  return _out;
20447 fail:
20448  return octave_value_list();
20449 }
20450 
20451 
20453  PLINT arg1 ;
20454  PLFLT *arg2 = (PLFLT *) 0 ;
20455  PLFLT *arg3 = (PLFLT *) 0 ;
20456  PLINT arg4 ;
20457  Matrix temp1 ;
20458  Matrix temp3 ;
20459  int val4 ;
20460  int ecode4 = 0 ;
20461  octave_value_list _out;
20462  octave_value_list *_outp=&_out;
20463  octave_value _outv;
20464 
20465  if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
20466  SWIG_fail;
20467  }
20468  {
20469  if ( _n_dims( args(0) ) > 1 )
20470  {
20471  error( "argument must be a scalar or vector" ); SWIG_fail;
20472  }
20473  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20474  temp1 = args(0).matrix_value();
20475  arg2 = &temp1( 0, 0 );
20476  }
20477  {
20478  if ( _n_dims( args(1) ) > 1 )
20479  {
20480  error( "argument must be a scalar or vector" ); SWIG_fail;
20481  }
20482  if ( _dim( args(1), 0 ) != Alen )
20483  {
20484  error( "argument vectors must be same length" ); SWIG_fail;
20485  }
20486  temp3 = args(1).matrix_value();
20487  arg3 = &temp3( 0, 0 );
20488  }
20489  ecode4 = SWIG_AsVal_int(args(2), &val4);
20490  if (!SWIG_IsOK(ecode4)) {
20491  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
20492  }
20493  arg4 = static_cast< PLINT >(val4);
20494  plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
20495  _outv = octave_value();
20496  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20497  {
20498 
20499  }
20500  {
20501 
20502  }
20503  return _out;
20504 fail:
20505  {
20506 
20507  }
20508  {
20509 
20510  }
20511  return octave_value_list();
20512 }
20513 
20514 
20516  PLINT arg1 ;
20517  PLFLT *arg2 = (PLFLT *) 0 ;
20518  PLFLT *arg3 = (PLFLT *) 0 ;
20519  PLFLT *arg4 = (PLFLT *) 0 ;
20520  PLINT arg5 ;
20521  Matrix temp1 ;
20522  Matrix temp3 ;
20523  Matrix temp4 ;
20524  int val5 ;
20525  int ecode5 = 0 ;
20526  octave_value_list _out;
20527  octave_value_list *_outp=&_out;
20528  octave_value _outv;
20529 
20530  if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
20531  SWIG_fail;
20532  }
20533  {
20534  if ( _n_dims( args(0) ) > 1 )
20535  {
20536  error( "argument must be a scalar or vector" ); SWIG_fail;
20537  }
20538  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20539  temp1 = args(0).matrix_value();
20540  arg2 = &temp1( 0, 0 );
20541  }
20542  {
20543  if ( _n_dims( args(1) ) > 1 )
20544  {
20545  error( "argument must be a scalar or vector" ); SWIG_fail;
20546  }
20547  if ( _dim( args(1), 0 ) != Alen )
20548  {
20549  error( "argument vectors must be same length" ); SWIG_fail;
20550  }
20551  temp3 = args(1).matrix_value();
20552  arg3 = &temp3( 0, 0 );
20553  }
20554  {
20555  if ( _n_dims( args(2) ) > 1 )
20556  {
20557  error( "argument must be a scalar or vector" ); SWIG_fail;
20558  }
20559  if ( _dim( args(2), 0 ) != Alen )
20560  {
20561  error( "argument vectors must be same length" ); SWIG_fail;
20562  }
20563  temp4 = args(2).matrix_value();
20564  arg4 = &temp4( 0, 0 );
20565  }
20566  ecode5 = SWIG_AsVal_int(args(3), &val5);
20567  if (!SWIG_IsOK(ecode5)) {
20568  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
20569  }
20570  arg5 = static_cast< PLINT >(val5);
20571  plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
20572  _outv = octave_value();
20573  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20574  {
20575 
20576  }
20577  {
20578 
20579  }
20580  {
20581 
20582  }
20583  return _out;
20584 fail:
20585  {
20586 
20587  }
20588  {
20589 
20590  }
20591  {
20592 
20593  }
20594  return octave_value_list();
20595 }
20596 
20597 
20599  PLINT arg1 ;
20600  PLFLT *arg2 = (PLFLT *) 0 ;
20601  PLFLT *arg3 = (PLFLT *) 0 ;
20602  PLFLT *arg4 = (PLFLT *) 0 ;
20603  PLBOOL *arg5 = (PLBOOL *) 0 ;
20604  PLBOOL arg6 ;
20605  Matrix temp1 ;
20606  Matrix temp3 ;
20607  Matrix temp4 ;
20608  Matrix temp5 ;
20609  int val6 ;
20610  int ecode6 = 0 ;
20611  octave_value_list _out;
20612  octave_value_list *_outp=&_out;
20613  octave_value _outv;
20614 
20615  if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
20616  SWIG_fail;
20617  }
20618  {
20619  if ( _n_dims( args(0) ) > 1 )
20620  {
20621  error( "argument must be a scalar or vector" ); SWIG_fail;
20622  }
20623  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20624  temp1 = args(0).matrix_value();
20625  arg2 = &temp1( 0, 0 );
20626  }
20627  {
20628  if ( _n_dims( args(1) ) > 1 )
20629  {
20630  error( "argument must be a scalar or vector" ); SWIG_fail;
20631  }
20632  if ( _dim( args(1), 0 ) != Alen )
20633  {
20634  error( "argument vectors must be same length" ); SWIG_fail;
20635  }
20636  temp3 = args(1).matrix_value();
20637  arg3 = &temp3( 0, 0 );
20638  }
20639  {
20640  if ( _n_dims( args(2) ) > 1 )
20641  {
20642  error( "argument must be a scalar or vector" ); SWIG_fail;
20643  }
20644  if ( _dim( args(2), 0 ) != Alen )
20645  {
20646  error( "argument vectors must be same length" ); SWIG_fail;
20647  }
20648  temp4 = args(2).matrix_value();
20649  arg4 = &temp4( 0, 0 );
20650  }
20651  {
20652  if ( _n_dims( args(3) ) > 1 )
20653  {
20654  error( "argument must be a scalar or vector" ); SWIG_fail;
20655  }
20656  if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
20657  {
20658  error( "argument vector must be same length or one less" ); SWIG_fail;
20659  }
20660  temp5 = args(3).matrix_value();
20661  arg5 = new PLINT[Alen];
20662  _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
20663  }
20664  ecode6 = SWIG_AsVal_int(args(4), &val6);
20665  if (!SWIG_IsOK(ecode6)) {
20666  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
20667  }
20668  arg6 = static_cast< PLBOOL >(val6);
20669  plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
20670  _outv = octave_value();
20671  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20672  {
20673 
20674  }
20675  {
20676 
20677  }
20678  {
20679 
20680  }
20681  {
20682  delete [] arg5;
20683  }
20684  return _out;
20685 fail:
20686  {
20687 
20688  }
20689  {
20690 
20691  }
20692  {
20693 
20694  }
20695  {
20696  delete [] arg5;
20697  }
20698  return octave_value_list();
20699 }
20700 
20701 
20703  PLINT arg1 ;
20704  PLINT arg2 ;
20705  int val1 ;
20706  int ecode1 = 0 ;
20707  int val2 ;
20708  int ecode2 = 0 ;
20709  octave_value_list _out;
20710  octave_value_list *_outp=&_out;
20711  octave_value _outv;
20712 
20713  if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
20714  SWIG_fail;
20715  }
20716  ecode1 = SWIG_AsVal_int(args(0), &val1);
20717  if (!SWIG_IsOK(ecode1)) {
20718  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
20719  }
20720  arg1 = static_cast< PLINT >(val1);
20721  ecode2 = SWIG_AsVal_int(args(1), &val2);
20722  if (!SWIG_IsOK(ecode2)) {
20723  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
20724  }
20725  arg2 = static_cast< PLINT >(val2);
20726  plprec(arg1,arg2);
20727  _outv = octave_value();
20728  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20729  return _out;
20730 fail:
20731  return octave_value_list();
20732 }
20733 
20734 
20736  PLINT arg1 ;
20737  int val1 ;
20738  int ecode1 = 0 ;
20739  octave_value_list _out;
20740  octave_value_list *_outp=&_out;
20741  octave_value _outv;
20742 
20743  if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
20744  SWIG_fail;
20745  }
20746  ecode1 = SWIG_AsVal_int(args(0), &val1);
20747  if (!SWIG_IsOK(ecode1)) {
20748  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
20749  }
20750  arg1 = static_cast< PLINT >(val1);
20751  plpsty(arg1);
20752  _outv = octave_value();
20753  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20754  return _out;
20755 fail:
20756  return octave_value_list();
20757 }
20758 
20759 
20761  PLFLT arg1 ;
20762  PLFLT arg2 ;
20763  PLFLT arg3 ;
20764  PLFLT arg4 ;
20765  PLFLT arg5 ;
20766  char *arg6 = (char *) 0 ;
20767  double val1 ;
20768  int ecode1 = 0 ;
20769  double val2 ;
20770  int ecode2 = 0 ;
20771  double val3 ;
20772  int ecode3 = 0 ;
20773  double val4 ;
20774  int ecode4 = 0 ;
20775  double val5 ;
20776  int ecode5 = 0 ;
20777  int res6 ;
20778  char *buf6 = 0 ;
20779  int alloc6 = 0 ;
20780  octave_value_list _out;
20781  octave_value_list *_outp=&_out;
20782  octave_value _outv;
20783 
20784  if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
20785  SWIG_fail;
20786  }
20787  ecode1 = SWIG_AsVal_double(args(0), &val1);
20788  if (!SWIG_IsOK(ecode1)) {
20789  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
20790  }
20791  arg1 = static_cast< PLFLT >(val1);
20792  ecode2 = SWIG_AsVal_double(args(1), &val2);
20793  if (!SWIG_IsOK(ecode2)) {
20794  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
20795  }
20796  arg2 = static_cast< PLFLT >(val2);
20797  ecode3 = SWIG_AsVal_double(args(2), &val3);
20798  if (!SWIG_IsOK(ecode3)) {
20799  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
20800  }
20801  arg3 = static_cast< PLFLT >(val3);
20802  ecode4 = SWIG_AsVal_double(args(3), &val4);
20803  if (!SWIG_IsOK(ecode4)) {
20804  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
20805  }
20806  arg4 = static_cast< PLFLT >(val4);
20807  ecode5 = SWIG_AsVal_double(args(4), &val5);
20808  if (!SWIG_IsOK(ecode5)) {
20809  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
20810  }
20811  arg5 = static_cast< PLFLT >(val5);
20812  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
20813  if (!SWIG_IsOK(res6)) {
20814  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
20815  }
20816  arg6 = reinterpret_cast< char * >(buf6);
20817  plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
20818  _outv = octave_value();
20819  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20820  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
20821  return _out;
20822 fail:
20823  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
20824  return octave_value_list();
20825 }
20826 
20827 
20829  PLFLT arg1 ;
20830  PLFLT arg2 ;
20831  PLFLT arg3 ;
20832  PLFLT arg4 ;
20833  PLFLT arg5 ;
20834  PLFLT arg6 ;
20835  PLFLT arg7 ;
20836  PLFLT arg8 ;
20837  PLFLT arg9 ;
20838  PLFLT arg10 ;
20839  char *arg11 = (char *) 0 ;
20840  double val1 ;
20841  int ecode1 = 0 ;
20842  double val2 ;
20843  int ecode2 = 0 ;
20844  double val3 ;
20845  int ecode3 = 0 ;
20846  double val4 ;
20847  int ecode4 = 0 ;
20848  double val5 ;
20849  int ecode5 = 0 ;
20850  double val6 ;
20851  int ecode6 = 0 ;
20852  double val7 ;
20853  int ecode7 = 0 ;
20854  double val8 ;
20855  int ecode8 = 0 ;
20856  double val9 ;
20857  int ecode9 = 0 ;
20858  double val10 ;
20859  int ecode10 = 0 ;
20860  int res11 ;
20861  char *buf11 = 0 ;
20862  int alloc11 = 0 ;
20863  octave_value_list _out;
20864  octave_value_list *_outp=&_out;
20865  octave_value _outv;
20866 
20867  if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
20868  SWIG_fail;
20869  }
20870  ecode1 = SWIG_AsVal_double(args(0), &val1);
20871  if (!SWIG_IsOK(ecode1)) {
20872  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
20873  }
20874  arg1 = static_cast< PLFLT >(val1);
20875  ecode2 = SWIG_AsVal_double(args(1), &val2);
20876  if (!SWIG_IsOK(ecode2)) {
20877  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
20878  }
20879  arg2 = static_cast< PLFLT >(val2);
20880  ecode3 = SWIG_AsVal_double(args(2), &val3);
20881  if (!SWIG_IsOK(ecode3)) {
20882  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
20883  }
20884  arg3 = static_cast< PLFLT >(val3);
20885  ecode4 = SWIG_AsVal_double(args(3), &val4);
20886  if (!SWIG_IsOK(ecode4)) {
20887  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
20888  }
20889  arg4 = static_cast< PLFLT >(val4);
20890  ecode5 = SWIG_AsVal_double(args(4), &val5);
20891  if (!SWIG_IsOK(ecode5)) {
20892  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
20893  }
20894  arg5 = static_cast< PLFLT >(val5);
20895  ecode6 = SWIG_AsVal_double(args(5), &val6);
20896  if (!SWIG_IsOK(ecode6)) {
20897  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
20898  }
20899  arg6 = static_cast< PLFLT >(val6);
20900  ecode7 = SWIG_AsVal_double(args(6), &val7);
20901  if (!SWIG_IsOK(ecode7)) {
20902  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
20903  }
20904  arg7 = static_cast< PLFLT >(val7);
20905  ecode8 = SWIG_AsVal_double(args(7), &val8);
20906  if (!SWIG_IsOK(ecode8)) {
20907  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
20908  }
20909  arg8 = static_cast< PLFLT >(val8);
20910  ecode9 = SWIG_AsVal_double(args(8), &val9);
20911  if (!SWIG_IsOK(ecode9)) {
20912  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
20913  }
20914  arg9 = static_cast< PLFLT >(val9);
20915  ecode10 = SWIG_AsVal_double(args(9), &val10);
20916  if (!SWIG_IsOK(ecode10)) {
20917  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
20918  }
20919  arg10 = static_cast< PLFLT >(val10);
20920  res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
20921  if (!SWIG_IsOK(res11)) {
20922  SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
20923  }
20924  arg11 = reinterpret_cast< char * >(buf11);
20925  plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
20926  _outv = octave_value();
20927  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20928  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
20929  return _out;
20930 fail:
20931  if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
20932  return octave_value_list();
20933 }
20934 
20935 
20937  octave_value_list _out;
20938  octave_value_list *_outp=&_out;
20939  octave_value _outv;
20940  PLFLT result;
20941 
20942  if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
20943  SWIG_fail;
20944  }
20945  result = (PLFLT)plrandd();
20946  _outv = SWIG_From_double(static_cast< double >(result));
20947  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20948  return _out;
20949 fail:
20950  return octave_value_list();
20951 }
20952 
20953 
20955  octave_value_list _out;
20956  octave_value_list *_outp=&_out;
20957  octave_value _outv;
20958 
20959  if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
20960  SWIG_fail;
20961  }
20962  plreplot();
20963  _outv = octave_value();
20964  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20965  return _out;
20966 fail:
20967  return octave_value_list();
20968 }
20969 
20970 
20972  PLFLT arg1 ;
20973  PLFLT arg2 ;
20974  PLFLT arg3 ;
20975  PLFLT *arg4 = (PLFLT *) 0 ;
20976  PLFLT *arg5 = (PLFLT *) 0 ;
20977  PLFLT *arg6 = (PLFLT *) 0 ;
20978  double val1 ;
20979  int ecode1 = 0 ;
20980  double val2 ;
20981  int ecode2 = 0 ;
20982  double val3 ;
20983  int ecode3 = 0 ;
20984  PLFLT temp4 ;
20985  int res4 = SWIG_TMPOBJ ;
20986  PLFLT temp5 ;
20987  int res5 = SWIG_TMPOBJ ;
20988  PLFLT temp6 ;
20989  int res6 = SWIG_TMPOBJ ;
20990  octave_value_list _out;
20991  octave_value_list *_outp=&_out;
20992  octave_value _outv;
20993 
20994  arg4 = &temp4;
20995  arg5 = &temp5;
20996  arg6 = &temp6;
20997  if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
20998  SWIG_fail;
20999  }
21000  ecode1 = SWIG_AsVal_double(args(0), &val1);
21001  if (!SWIG_IsOK(ecode1)) {
21002  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
21003  }
21004  arg1 = static_cast< PLFLT >(val1);
21005  ecode2 = SWIG_AsVal_double(args(1), &val2);
21006  if (!SWIG_IsOK(ecode2)) {
21007  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
21008  }
21009  arg2 = static_cast< PLFLT >(val2);
21010  ecode3 = SWIG_AsVal_double(args(2), &val3);
21011  if (!SWIG_IsOK(ecode3)) {
21012  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
21013  }
21014  arg3 = static_cast< PLFLT >(val3);
21015  plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
21016  _outv = octave_value();
21017  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21018  if (SWIG_IsTmpObj(res4)) {
21019  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
21020  } else {
21021  int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21022  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
21023  }
21024  if (SWIG_IsTmpObj(res5)) {
21025  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
21026  } else {
21027  int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21028  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
21029  }
21030  if (SWIG_IsTmpObj(res6)) {
21031  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
21032  } else {
21033  int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21034  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
21035  }
21036  return _out;
21037 fail:
21038  return octave_value_list();
21039 }
21040 
21041 
21043  PLFLT arg1 ;
21044  PLFLT arg2 ;
21045  double val1 ;
21046  int ecode1 = 0 ;
21047  double val2 ;
21048  int ecode2 = 0 ;
21049  octave_value_list _out;
21050  octave_value_list *_outp=&_out;
21051  octave_value _outv;
21052 
21053  if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
21054  SWIG_fail;
21055  }
21056  ecode1 = SWIG_AsVal_double(args(0), &val1);
21057  if (!SWIG_IsOK(ecode1)) {
21058  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
21059  }
21060  arg1 = static_cast< PLFLT >(val1);
21061  ecode2 = SWIG_AsVal_double(args(1), &val2);
21062  if (!SWIG_IsOK(ecode2)) {
21063  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
21064  }
21065  arg2 = static_cast< PLFLT >(val2);
21066  plschr(arg1,arg2);
21067  _outv = octave_value();
21068  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21069  return _out;
21070 fail:
21071  return octave_value_list();
21072 }
21073 
21074 
21076  PLINT *arg1 = (PLINT *) 0 ;
21077  PLINT *arg2 = (PLINT *) 0 ;
21078  PLINT *arg3 = (PLINT *) 0 ;
21079  PLINT arg4 ;
21080  Matrix temp1 ;
21081  Matrix temp2 ;
21082  Matrix temp3 ;
21083  octave_value_list _out;
21084  octave_value_list *_outp=&_out;
21085  octave_value _outv;
21086 
21087  if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
21088  SWIG_fail;
21089  }
21090  {
21091  if ( _n_dims( args(0) ) > 1 )
21092  {
21093  error( "argument must be a scalar or vector" ); SWIG_fail;
21094  }
21095  Alen = (PLINT) ( _dim( args(0), 0 ) );
21096  temp1 = args(0).matrix_value();
21097  arg1 = new PLINT[Alen];
21098  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21099  }
21100  {
21101  if ( _n_dims( args(1) ) > 1 )
21102  {
21103  error( "argument must be a scalar or vector" ); SWIG_fail;
21104  }
21105  if ( _dim( args(1), 0 ) != Alen )
21106  {
21107  error( "argument vectors must be same length" ); SWIG_fail;
21108  }
21109  temp2 = args(1).matrix_value();
21110  arg2 = new PLINT[Alen];
21111  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21112  }
21113  {
21114  if ( _n_dims( args(2) ) > 1 )
21115  {
21116  error( "argument must be a scalar or vector" ); SWIG_fail;
21117  }
21118  if ( _dim( args(2), 0 ) != Alen )
21119  {
21120  error( "argument vectors must be same length" ); SWIG_fail;
21121  }
21122  temp3 = args(2).matrix_value();
21123  arg3 = new PLINT[Alen];
21124  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21125  arg4 = Alen;
21126  }
21127  plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
21128  _outv = octave_value();
21129  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21130  {
21131  delete [] arg1;
21132  }
21133  {
21134  delete [] arg2;
21135  }
21136  {
21137  delete [] arg3;
21138  }
21139  return _out;
21140 fail:
21141  {
21142  delete [] arg1;
21143  }
21144  {
21145  delete [] arg2;
21146  }
21147  {
21148  delete [] arg3;
21149  }
21150  return octave_value_list();
21151 }
21152 
21153 
21155  PLINT *arg1 = (PLINT *) 0 ;
21156  PLINT *arg2 = (PLINT *) 0 ;
21157  PLINT *arg3 = (PLINT *) 0 ;
21158  PLFLT *arg4 = (PLFLT *) 0 ;
21159  PLINT arg5 ;
21160  Matrix temp1 ;
21161  Matrix temp2 ;
21162  Matrix temp3 ;
21163  Matrix temp4 ;
21164  octave_value_list _out;
21165  octave_value_list *_outp=&_out;
21166  octave_value _outv;
21167 
21168  if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
21169  SWIG_fail;
21170  }
21171  {
21172  if ( _n_dims( args(0) ) > 1 )
21173  {
21174  error( "argument must be a scalar or vector" ); SWIG_fail;
21175  }
21176  Alen = (PLINT) ( _dim( args(0), 0 ) );
21177  temp1 = args(0).matrix_value();
21178  arg1 = new PLINT[Alen];
21179  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21180  }
21181  {
21182  if ( _n_dims( args(1) ) > 1 )
21183  {
21184  error( "argument must be a scalar or vector" ); SWIG_fail;
21185  }
21186  if ( _dim( args(1), 0 ) != Alen )
21187  {
21188  error( "argument vectors must be same length" ); SWIG_fail;
21189  }
21190  temp2 = args(1).matrix_value();
21191  arg2 = new PLINT[Alen];
21192  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21193  }
21194  {
21195  if ( _n_dims( args(2) ) > 1 )
21196  {
21197  error( "argument must be a scalar or vector" ); SWIG_fail;
21198  }
21199  if ( _dim( args(2), 0 ) != Alen )
21200  {
21201  error( "argument vectors must be same length" ); SWIG_fail;
21202  }
21203  temp3 = args(2).matrix_value();
21204  arg3 = new PLINT[Alen];
21205  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21206  }
21207  {
21208  if ( _n_dims( args(3) ) > 1 )
21209  {
21210  error( "argument must be a scalar or vector" ); SWIG_fail;
21211  }
21212  if ( _dim( args(3), 0 ) != Alen )
21213  {
21214  error( "argument vectors must be same length" ); SWIG_fail;
21215  }
21216  temp4 = args(3).matrix_value();
21217  arg4 = &temp4( 0, 0 );
21218  arg5 = (PLINT) ( _dim( args(3), 0 ) );
21219  }
21220  plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
21221  _outv = octave_value();
21222  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21223  {
21224  delete [] arg1;
21225  }
21226  {
21227  delete [] arg2;
21228  }
21229  {
21230  delete [] arg3;
21231  }
21232  {
21233 
21234  }
21235  return _out;
21236 fail:
21237  {
21238  delete [] arg1;
21239  }
21240  {
21241  delete [] arg2;
21242  }
21243  {
21244  delete [] arg3;
21245  }
21246  {
21247 
21248  }
21249  return octave_value_list();
21250 }
21251 
21252 
21254  PLINT arg1 ;
21255  int val1 ;
21256  int ecode1 = 0 ;
21257  octave_value_list _out;
21258  octave_value_list *_outp=&_out;
21259  octave_value _outv;
21260 
21261  if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
21262  SWIG_fail;
21263  }
21264  ecode1 = SWIG_AsVal_int(args(0), &val1);
21265  if (!SWIG_IsOK(ecode1)) {
21266  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
21267  }
21268  arg1 = static_cast< PLINT >(val1);
21269  plscmap0n(arg1);
21270  _outv = octave_value();
21271  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21272  return _out;
21273 fail:
21274  return octave_value_list();
21275 }
21276 
21277 
21279  PLINT *arg1 = (PLINT *) 0 ;
21280  PLINT *arg2 = (PLINT *) 0 ;
21281  PLINT *arg3 = (PLINT *) 0 ;
21282  PLINT arg4 ;
21283  Matrix temp1 ;
21284  Matrix temp2 ;
21285  Matrix temp3 ;
21286  octave_value_list _out;
21287  octave_value_list *_outp=&_out;
21288  octave_value _outv;
21289 
21290  if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
21291  SWIG_fail;
21292  }
21293  {
21294  if ( _n_dims( args(0) ) > 1 )
21295  {
21296  error( "argument must be a scalar or vector" ); SWIG_fail;
21297  }
21298  Alen = (PLINT) ( _dim( args(0), 0 ) );
21299  temp1 = args(0).matrix_value();
21300  arg1 = new PLINT[Alen];
21301  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21302  }
21303  {
21304  if ( _n_dims( args(1) ) > 1 )
21305  {
21306  error( "argument must be a scalar or vector" ); SWIG_fail;
21307  }
21308  if ( _dim( args(1), 0 ) != Alen )
21309  {
21310  error( "argument vectors must be same length" ); SWIG_fail;
21311  }
21312  temp2 = args(1).matrix_value();
21313  arg2 = new PLINT[Alen];
21314  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21315  }
21316  {
21317  if ( _n_dims( args(2) ) > 1 )
21318  {
21319  error( "argument must be a scalar or vector" ); SWIG_fail;
21320  }
21321  if ( _dim( args(2), 0 ) != Alen )
21322  {
21323  error( "argument vectors must be same length" ); SWIG_fail;
21324  }
21325  temp3 = args(2).matrix_value();
21326  arg3 = new PLINT[Alen];
21327  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21328  arg4 = Alen;
21329  }
21330  plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
21331  _outv = octave_value();
21332  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21333  {
21334  delete [] arg1;
21335  }
21336  {
21337  delete [] arg2;
21338  }
21339  {
21340  delete [] arg3;
21341  }
21342  return _out;
21343 fail:
21344  {
21345  delete [] arg1;
21346  }
21347  {
21348  delete [] arg2;
21349  }
21350  {
21351  delete [] arg3;
21352  }
21353  return octave_value_list();
21354 }
21355 
21356 
21358  PLINT *arg1 = (PLINT *) 0 ;
21359  PLINT *arg2 = (PLINT *) 0 ;
21360  PLINT *arg3 = (PLINT *) 0 ;
21361  PLFLT *arg4 = (PLFLT *) 0 ;
21362  PLINT arg5 ;
21363  Matrix temp1 ;
21364  Matrix temp2 ;
21365  Matrix temp3 ;
21366  Matrix temp4 ;
21367  octave_value_list _out;
21368  octave_value_list *_outp=&_out;
21369  octave_value _outv;
21370 
21371  if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
21372  SWIG_fail;
21373  }
21374  {
21375  if ( _n_dims( args(0) ) > 1 )
21376  {
21377  error( "argument must be a scalar or vector" ); SWIG_fail;
21378  }
21379  Alen = (PLINT) ( _dim( args(0), 0 ) );
21380  temp1 = args(0).matrix_value();
21381  arg1 = new PLINT[Alen];
21382  _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21383  }
21384  {
21385  if ( _n_dims( args(1) ) > 1 )
21386  {
21387  error( "argument must be a scalar or vector" ); SWIG_fail;
21388  }
21389  if ( _dim( args(1), 0 ) != Alen )
21390  {
21391  error( "argument vectors must be same length" ); SWIG_fail;
21392  }
21393  temp2 = args(1).matrix_value();
21394  arg2 = new PLINT[Alen];
21395  _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21396  }
21397  {
21398  if ( _n_dims( args(2) ) > 1 )
21399  {
21400  error( "argument must be a scalar or vector" ); SWIG_fail;
21401  }
21402  if ( _dim( args(2), 0 ) != Alen )
21403  {
21404  error( "argument vectors must be same length" ); SWIG_fail;
21405  }
21406  temp3 = args(2).matrix_value();
21407  arg3 = new PLINT[Alen];
21408  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21409  }
21410  {
21411  if ( _n_dims( args(3) ) > 1 )
21412  {
21413  error( "argument must be a scalar or vector" ); SWIG_fail;
21414  }
21415  if ( _dim( args(3), 0 ) != Alen )
21416  {
21417  error( "argument vectors must be same length" ); SWIG_fail;
21418  }
21419  temp4 = args(3).matrix_value();
21420  arg4 = &temp4( 0, 0 );
21421  arg5 = (PLINT) ( _dim( args(3), 0 ) );
21422  }
21423  plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
21424  _outv = octave_value();
21425  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21426  {
21427  delete [] arg1;
21428  }
21429  {
21430  delete [] arg2;
21431  }
21432  {
21433  delete [] arg3;
21434  }
21435  {
21436 
21437  }
21438  return _out;
21439 fail:
21440  {
21441  delete [] arg1;
21442  }
21443  {
21444  delete [] arg2;
21445  }
21446  {
21447  delete [] arg3;
21448  }
21449  {
21450 
21451  }
21452  return octave_value_list();
21453 }
21454 
21455 
21457  PLBOOL arg1 ;
21458  PLINT arg2 ;
21459  PLFLT *arg3 = (PLFLT *) 0 ;
21460  PLFLT *arg4 = (PLFLT *) 0 ;
21461  PLFLT *arg5 = (PLFLT *) 0 ;
21462  PLFLT *arg6 = (PLFLT *) 0 ;
21463  PLBOOL *arg7 = (PLBOOL *) 0 ;
21464  int val1 ;
21465  int ecode1 = 0 ;
21466  Matrix temp2 ;
21467  Matrix temp4 ;
21468  Matrix temp5 ;
21469  Matrix temp6 ;
21470  Matrix temp7 ;
21471  octave_value_list _out;
21472  octave_value_list *_outp=&_out;
21473  octave_value _outv;
21474 
21475  if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
21476  SWIG_fail;
21477  }
21478  ecode1 = SWIG_AsVal_int(args(0), &val1);
21479  if (!SWIG_IsOK(ecode1)) {
21480  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
21481  }
21482  arg1 = static_cast< PLBOOL >(val1);
21483  {
21484  if ( _n_dims( args(1) ) > 1 )
21485  {
21486  error( "argument must be a scalar or vector" ); SWIG_fail;
21487  }
21488  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
21489  temp2 = args(1).matrix_value();
21490  arg3 = &temp2( 0, 0 );
21491  }
21492  {
21493  if ( _n_dims( args(2) ) > 1 )
21494  {
21495  error( "argument must be a scalar or vector" ); SWIG_fail;
21496  }
21497  if ( _dim( args(2), 0 ) != Alen )
21498  {
21499  error( "argument vectors must be same length" ); SWIG_fail;
21500  }
21501  temp4 = args(2).matrix_value();
21502  arg4 = &temp4( 0, 0 );
21503  }
21504  {
21505  if ( _n_dims( args(3) ) > 1 )
21506  {
21507  error( "argument must be a scalar or vector" ); SWIG_fail;
21508  }
21509  if ( _dim( args(3), 0 ) != Alen )
21510  {
21511  error( "argument vectors must be same length" ); SWIG_fail;
21512  }
21513  temp5 = args(3).matrix_value();
21514  arg5 = &temp5( 0, 0 );
21515  }
21516  {
21517  if ( _n_dims( args(4) ) > 1 )
21518  {
21519  error( "argument must be a scalar or vector" ); SWIG_fail;
21520  }
21521  if ( _dim( args(4), 0 ) != Alen )
21522  {
21523  error( "argument vectors must be same length" ); SWIG_fail;
21524  }
21525  temp6 = args(4).matrix_value();
21526  arg6 = &temp6( 0, 0 );
21527  }
21528  {
21529  if ( _n_dims( args(5) ) > 1 )
21530  {
21531  error( "argument must be a scalar or vector" ); SWIG_fail;
21532  }
21533  if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
21534  {
21535  error( "argument vector must be same length or one less" ); SWIG_fail;
21536  }
21537  temp7 = args(5).matrix_value();
21538  arg7 = new PLINT[Alen];
21539  _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
21540  }
21541  plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
21542  _outv = octave_value();
21543  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21544  {
21545 
21546  }
21547  {
21548 
21549  }
21550  {
21551 
21552  }
21553  {
21554 
21555  }
21556  {
21557  delete [] arg7;
21558  }
21559  return _out;
21560 fail:
21561  {
21562 
21563  }
21564  {
21565 
21566  }
21567  {
21568 
21569  }
21570  {
21571 
21572  }
21573  {
21574  delete [] arg7;
21575  }
21576  return octave_value_list();
21577 }
21578 
21579 
21581  PLBOOL arg1 ;
21582  PLINT arg2 ;
21583  PLFLT *arg3 = (PLFLT *) 0 ;
21584  PLFLT *arg4 = (PLFLT *) 0 ;
21585  PLFLT *arg5 = (PLFLT *) 0 ;
21586  PLFLT *arg6 = (PLFLT *) 0 ;
21587  PLFLT *arg7 = (PLFLT *) 0 ;
21588  PLBOOL *arg8 = (PLBOOL *) 0 ;
21589  int val1 ;
21590  int ecode1 = 0 ;
21591  Matrix temp2 ;
21592  Matrix temp4 ;
21593  Matrix temp5 ;
21594  Matrix temp6 ;
21595  Matrix temp7 ;
21596  Matrix temp8 ;
21597  octave_value_list _out;
21598  octave_value_list *_outp=&_out;
21599  octave_value _outv;
21600 
21601  if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
21602  SWIG_fail;
21603  }
21604  ecode1 = SWIG_AsVal_int(args(0), &val1);
21605  if (!SWIG_IsOK(ecode1)) {
21606  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
21607  }
21608  arg1 = static_cast< PLBOOL >(val1);
21609  {
21610  if ( _n_dims( args(1) ) > 1 )
21611  {
21612  error( "argument must be a scalar or vector" ); SWIG_fail;
21613  }
21614  arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
21615  temp2 = args(1).matrix_value();
21616  arg3 = &temp2( 0, 0 );
21617  }
21618  {
21619  if ( _n_dims( args(2) ) > 1 )
21620  {
21621  error( "argument must be a scalar or vector" ); SWIG_fail;
21622  }
21623  if ( _dim( args(2), 0 ) != Alen )
21624  {
21625  error( "argument vectors must be same length" ); SWIG_fail;
21626  }
21627  temp4 = args(2).matrix_value();
21628  arg4 = &temp4( 0, 0 );
21629  }
21630  {
21631  if ( _n_dims( args(3) ) > 1 )
21632  {
21633  error( "argument must be a scalar or vector" ); SWIG_fail;
21634  }
21635  if ( _dim( args(3), 0 ) != Alen )
21636  {
21637  error( "argument vectors must be same length" ); SWIG_fail;
21638  }
21639  temp5 = args(3).matrix_value();
21640  arg5 = &temp5( 0, 0 );
21641  }
21642  {
21643  if ( _n_dims( args(4) ) > 1 )
21644  {
21645  error( "argument must be a scalar or vector" ); SWIG_fail;
21646  }
21647  if ( _dim( args(4), 0 ) != Alen )
21648  {
21649  error( "argument vectors must be same length" ); SWIG_fail;
21650  }
21651  temp6 = args(4).matrix_value();
21652  arg6 = &temp6( 0, 0 );
21653  }
21654  {
21655  if ( _n_dims( args(5) ) > 1 )
21656  {
21657  error( "argument must be a scalar or vector" ); SWIG_fail;
21658  }
21659  if ( _dim( args(5), 0 ) != Alen )
21660  {
21661  error( "argument vectors must be same length" ); SWIG_fail;
21662  }
21663  temp7 = args(5).matrix_value();
21664  arg7 = &temp7( 0, 0 );
21665  }
21666  {
21667  if ( _n_dims( args(6) ) > 1 )
21668  {
21669  error( "argument must be a scalar or vector" ); SWIG_fail;
21670  }
21671  if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
21672  {
21673  error( "argument vector must be same length or one less" ); SWIG_fail;
21674  }
21675  temp8 = args(6).matrix_value();
21676  arg8 = new PLINT[Alen];
21677  _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
21678  }
21679  plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
21680  _outv = octave_value();
21681  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21682  {
21683 
21684  }
21685  {
21686 
21687  }
21688  {
21689 
21690  }
21691  {
21692 
21693  }
21694  {
21695 
21696  }
21697  {
21698  delete [] arg8;
21699  }
21700  return _out;
21701 fail:
21702  {
21703 
21704  }
21705  {
21706 
21707  }
21708  {
21709 
21710  }
21711  {
21712 
21713  }
21714  {
21715 
21716  }
21717  {
21718  delete [] arg8;
21719  }
21720  return octave_value_list();
21721 }
21722 
21723 
21725  PLINT arg1 ;
21726  int val1 ;
21727  int ecode1 = 0 ;
21728  octave_value_list _out;
21729  octave_value_list *_outp=&_out;
21730  octave_value _outv;
21731 
21732  if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
21733  SWIG_fail;
21734  }
21735  ecode1 = SWIG_AsVal_int(args(0), &val1);
21736  if (!SWIG_IsOK(ecode1)) {
21737  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
21738  }
21739  arg1 = static_cast< PLINT >(val1);
21740  plscmap1n(arg1);
21741  _outv = octave_value();
21742  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21743  return _out;
21744 fail:
21745  return octave_value_list();
21746 }
21747 
21748 
21750  PLFLT arg1 ;
21751  PLFLT arg2 ;
21752  double val1 ;
21753  int ecode1 = 0 ;
21754  double val2 ;
21755  int ecode2 = 0 ;
21756  octave_value_list _out;
21757  octave_value_list *_outp=&_out;
21758  octave_value _outv;
21759 
21760  if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
21761  SWIG_fail;
21762  }
21763  ecode1 = SWIG_AsVal_double(args(0), &val1);
21764  if (!SWIG_IsOK(ecode1)) {
21765  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
21766  }
21767  arg1 = static_cast< PLFLT >(val1);
21768  ecode2 = SWIG_AsVal_double(args(1), &val2);
21769  if (!SWIG_IsOK(ecode2)) {
21770  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
21771  }
21772  arg2 = static_cast< PLFLT >(val2);
21773  plscmap1_range(arg1,arg2);
21774  _outv = octave_value();
21775  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21776  return _out;
21777 fail:
21778  return octave_value_list();
21779 }
21780 
21781 
21783  PLFLT *arg1 = (PLFLT *) 0 ;
21784  PLFLT *arg2 = (PLFLT *) 0 ;
21785  PLFLT temp1 ;
21786  int res1 = SWIG_TMPOBJ ;
21787  PLFLT temp2 ;
21788  int res2 = SWIG_TMPOBJ ;
21789  octave_value_list _out;
21790  octave_value_list *_outp=&_out;
21791  octave_value _outv;
21792 
21793  arg1 = &temp1;
21794  arg2 = &temp2;
21795  if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
21796  SWIG_fail;
21797  }
21798  plgcmap1_range(arg1,arg2);
21799  _outv = octave_value();
21800  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21801  if (SWIG_IsTmpObj(res1)) {
21802  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
21803  } else {
21804  int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21805  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
21806  }
21807  if (SWIG_IsTmpObj(res2)) {
21808  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
21809  } else {
21810  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21811  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21812  }
21813  return _out;
21814 fail:
21815  return octave_value_list();
21816 }
21817 
21818 
21820  PLINT arg1 ;
21821  PLINT arg2 ;
21822  PLINT arg3 ;
21823  PLINT arg4 ;
21824  int val1 ;
21825  int ecode1 = 0 ;
21826  int val2 ;
21827  int ecode2 = 0 ;
21828  int val3 ;
21829  int ecode3 = 0 ;
21830  int val4 ;
21831  int ecode4 = 0 ;
21832  octave_value_list _out;
21833  octave_value_list *_outp=&_out;
21834  octave_value _outv;
21835 
21836  if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
21837  SWIG_fail;
21838  }
21839  ecode1 = SWIG_AsVal_int(args(0), &val1);
21840  if (!SWIG_IsOK(ecode1)) {
21841  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
21842  }
21843  arg1 = static_cast< PLINT >(val1);
21844  ecode2 = SWIG_AsVal_int(args(1), &val2);
21845  if (!SWIG_IsOK(ecode2)) {
21846  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
21847  }
21848  arg2 = static_cast< PLINT >(val2);
21849  ecode3 = SWIG_AsVal_int(args(2), &val3);
21850  if (!SWIG_IsOK(ecode3)) {
21851  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
21852  }
21853  arg3 = static_cast< PLINT >(val3);
21854  ecode4 = SWIG_AsVal_int(args(3), &val4);
21855  if (!SWIG_IsOK(ecode4)) {
21856  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
21857  }
21858  arg4 = static_cast< PLINT >(val4);
21859  plscol0(arg1,arg2,arg3,arg4);
21860  _outv = octave_value();
21861  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21862  return _out;
21863 fail:
21864  return octave_value_list();
21865 }
21866 
21867 
21869  PLINT arg1 ;
21870  PLINT arg2 ;
21871  PLINT arg3 ;
21872  PLINT arg4 ;
21873  PLFLT arg5 ;
21874  int val1 ;
21875  int ecode1 = 0 ;
21876  int val2 ;
21877  int ecode2 = 0 ;
21878  int val3 ;
21879  int ecode3 = 0 ;
21880  int val4 ;
21881  int ecode4 = 0 ;
21882  double val5 ;
21883  int ecode5 = 0 ;
21884  octave_value_list _out;
21885  octave_value_list *_outp=&_out;
21886  octave_value _outv;
21887 
21888  if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
21889  SWIG_fail;
21890  }
21891  ecode1 = SWIG_AsVal_int(args(0), &val1);
21892  if (!SWIG_IsOK(ecode1)) {
21893  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
21894  }
21895  arg1 = static_cast< PLINT >(val1);
21896  ecode2 = SWIG_AsVal_int(args(1), &val2);
21897  if (!SWIG_IsOK(ecode2)) {
21898  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
21899  }
21900  arg2 = static_cast< PLINT >(val2);
21901  ecode3 = SWIG_AsVal_int(args(2), &val3);
21902  if (!SWIG_IsOK(ecode3)) {
21903  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
21904  }
21905  arg3 = static_cast< PLINT >(val3);
21906  ecode4 = SWIG_AsVal_int(args(3), &val4);
21907  if (!SWIG_IsOK(ecode4)) {
21908  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
21909  }
21910  arg4 = static_cast< PLINT >(val4);
21911  ecode5 = SWIG_AsVal_double(args(4), &val5);
21912  if (!SWIG_IsOK(ecode5)) {
21913  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
21914  }
21915  arg5 = static_cast< PLFLT >(val5);
21916  plscol0a(arg1,arg2,arg3,arg4,arg5);
21917  _outv = octave_value();
21918  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21919  return _out;
21920 fail:
21921  return octave_value_list();
21922 }
21923 
21924 
21926  PLINT arg1 ;
21927  PLINT arg2 ;
21928  PLINT arg3 ;
21929  int val1 ;
21930  int ecode1 = 0 ;
21931  int val2 ;
21932  int ecode2 = 0 ;
21933  int val3 ;
21934  int ecode3 = 0 ;
21935  octave_value_list _out;
21936  octave_value_list *_outp=&_out;
21937  octave_value _outv;
21938 
21939  if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
21940  SWIG_fail;
21941  }
21942  ecode1 = SWIG_AsVal_int(args(0), &val1);
21943  if (!SWIG_IsOK(ecode1)) {
21944  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
21945  }
21946  arg1 = static_cast< PLINT >(val1);
21947  ecode2 = SWIG_AsVal_int(args(1), &val2);
21948  if (!SWIG_IsOK(ecode2)) {
21949  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
21950  }
21951  arg2 = static_cast< PLINT >(val2);
21952  ecode3 = SWIG_AsVal_int(args(2), &val3);
21953  if (!SWIG_IsOK(ecode3)) {
21954  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
21955  }
21956  arg3 = static_cast< PLINT >(val3);
21957  plscolbg(arg1,arg2,arg3);
21958  _outv = octave_value();
21959  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21960  return _out;
21961 fail:
21962  return octave_value_list();
21963 }
21964 
21965 
21967  PLINT arg1 ;
21968  PLINT arg2 ;
21969  PLINT arg3 ;
21970  PLFLT arg4 ;
21971  int val1 ;
21972  int ecode1 = 0 ;
21973  int val2 ;
21974  int ecode2 = 0 ;
21975  int val3 ;
21976  int ecode3 = 0 ;
21977  double val4 ;
21978  int ecode4 = 0 ;
21979  octave_value_list _out;
21980  octave_value_list *_outp=&_out;
21981  octave_value _outv;
21982 
21983  if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
21984  SWIG_fail;
21985  }
21986  ecode1 = SWIG_AsVal_int(args(0), &val1);
21987  if (!SWIG_IsOK(ecode1)) {
21988  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
21989  }
21990  arg1 = static_cast< PLINT >(val1);
21991  ecode2 = SWIG_AsVal_int(args(1), &val2);
21992  if (!SWIG_IsOK(ecode2)) {
21993  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
21994  }
21995  arg2 = static_cast< PLINT >(val2);
21996  ecode3 = SWIG_AsVal_int(args(2), &val3);
21997  if (!SWIG_IsOK(ecode3)) {
21998  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
21999  }
22000  arg3 = static_cast< PLINT >(val3);
22001  ecode4 = SWIG_AsVal_double(args(3), &val4);
22002  if (!SWIG_IsOK(ecode4)) {
22003  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
22004  }
22005  arg4 = static_cast< PLFLT >(val4);
22006  plscolbga(arg1,arg2,arg3,arg4);
22007  _outv = octave_value();
22008  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22009  return _out;
22010 fail:
22011  return octave_value_list();
22012 }
22013 
22014 
22016  PLINT arg1 ;
22017  int val1 ;
22018  int ecode1 = 0 ;
22019  octave_value_list _out;
22020  octave_value_list *_outp=&_out;
22021  octave_value _outv;
22022 
22023  if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
22024  SWIG_fail;
22025  }
22026  ecode1 = SWIG_AsVal_int(args(0), &val1);
22027  if (!SWIG_IsOK(ecode1)) {
22028  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
22029  }
22030  arg1 = static_cast< PLINT >(val1);
22031  plscolor(arg1);
22032  _outv = octave_value();
22033  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22034  return _out;
22035 fail:
22036  return octave_value_list();
22037 }
22038 
22039 
22041  PLINT arg1 ;
22042  int val1 ;
22043  int ecode1 = 0 ;
22044  octave_value_list _out;
22045  octave_value_list *_outp=&_out;
22046  octave_value _outv;
22047 
22048  if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
22049  SWIG_fail;
22050  }
22051  ecode1 = SWIG_AsVal_int(args(0), &val1);
22052  if (!SWIG_IsOK(ecode1)) {
22053  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
22054  }
22055  arg1 = static_cast< PLINT >(val1);
22056  plscompression(arg1);
22057  _outv = octave_value();
22058  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22059  return _out;
22060 fail:
22061  return octave_value_list();
22062 }
22063 
22064 
22066  char *arg1 = (char *) 0 ;
22067  int res1 ;
22068  char *buf1 = 0 ;
22069  int alloc1 = 0 ;
22070  octave_value_list _out;
22071  octave_value_list *_outp=&_out;
22072  octave_value _outv;
22073 
22074  if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
22075  SWIG_fail;
22076  }
22077  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22078  if (!SWIG_IsOK(res1)) {
22079  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
22080  }
22081  arg1 = reinterpret_cast< char * >(buf1);
22082  plsdev((char const *)arg1);
22083  _outv = octave_value();
22084  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22085  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22086  return _out;
22087 fail:
22088  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22089  return octave_value_list();
22090 }
22091 
22092 
22094  PLFLT arg1 ;
22095  PLFLT arg2 ;
22096  PLFLT arg3 ;
22097  PLFLT arg4 ;
22098  double val1 ;
22099  int ecode1 = 0 ;
22100  double val2 ;
22101  int ecode2 = 0 ;
22102  double val3 ;
22103  int ecode3 = 0 ;
22104  double val4 ;
22105  int ecode4 = 0 ;
22106  octave_value_list _out;
22107  octave_value_list *_outp=&_out;
22108  octave_value _outv;
22109 
22110  if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
22111  SWIG_fail;
22112  }
22113  ecode1 = SWIG_AsVal_double(args(0), &val1);
22114  if (!SWIG_IsOK(ecode1)) {
22115  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
22116  }
22117  arg1 = static_cast< PLFLT >(val1);
22118  ecode2 = SWIG_AsVal_double(args(1), &val2);
22119  if (!SWIG_IsOK(ecode2)) {
22120  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
22121  }
22122  arg2 = static_cast< PLFLT >(val2);
22123  ecode3 = SWIG_AsVal_double(args(2), &val3);
22124  if (!SWIG_IsOK(ecode3)) {
22125  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
22126  }
22127  arg3 = static_cast< PLFLT >(val3);
22128  ecode4 = SWIG_AsVal_double(args(3), &val4);
22129  if (!SWIG_IsOK(ecode4)) {
22130  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
22131  }
22132  arg4 = static_cast< PLFLT >(val4);
22133  plsdidev(arg1,arg2,arg3,arg4);
22134  _outv = octave_value();
22135  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22136  return _out;
22137 fail:
22138  return octave_value_list();
22139 }
22140 
22141 
22143  PLINT arg1 ;
22144  PLINT arg2 ;
22145  PLINT arg3 ;
22146  PLINT arg4 ;
22147  PLFLT arg5 ;
22148  PLFLT arg6 ;
22149  int val1 ;
22150  int ecode1 = 0 ;
22151  int val2 ;
22152  int ecode2 = 0 ;
22153  int val3 ;
22154  int ecode3 = 0 ;
22155  int val4 ;
22156  int ecode4 = 0 ;
22157  double val5 ;
22158  int ecode5 = 0 ;
22159  double val6 ;
22160  int ecode6 = 0 ;
22161  octave_value_list _out;
22162  octave_value_list *_outp=&_out;
22163  octave_value _outv;
22164 
22165  if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
22166  SWIG_fail;
22167  }
22168  ecode1 = SWIG_AsVal_int(args(0), &val1);
22169  if (!SWIG_IsOK(ecode1)) {
22170  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
22171  }
22172  arg1 = static_cast< PLINT >(val1);
22173  ecode2 = SWIG_AsVal_int(args(1), &val2);
22174  if (!SWIG_IsOK(ecode2)) {
22175  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
22176  }
22177  arg2 = static_cast< PLINT >(val2);
22178  ecode3 = SWIG_AsVal_int(args(2), &val3);
22179  if (!SWIG_IsOK(ecode3)) {
22180  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
22181  }
22182  arg3 = static_cast< PLINT >(val3);
22183  ecode4 = SWIG_AsVal_int(args(3), &val4);
22184  if (!SWIG_IsOK(ecode4)) {
22185  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
22186  }
22187  arg4 = static_cast< PLINT >(val4);
22188  ecode5 = SWIG_AsVal_double(args(4), &val5);
22189  if (!SWIG_IsOK(ecode5)) {
22190  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
22191  }
22192  arg5 = static_cast< PLFLT >(val5);
22193  ecode6 = SWIG_AsVal_double(args(5), &val6);
22194  if (!SWIG_IsOK(ecode6)) {
22195  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
22196  }
22197  arg6 = static_cast< PLFLT >(val6);
22198  plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
22199  _outv = octave_value();
22200  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22201  return _out;
22202 fail:
22203  return octave_value_list();
22204 }
22205 
22206 
22208  PLFLT arg1 ;
22209  double val1 ;
22210  int ecode1 = 0 ;
22211  octave_value_list _out;
22212  octave_value_list *_outp=&_out;
22213  octave_value _outv;
22214 
22215  if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
22216  SWIG_fail;
22217  }
22218  ecode1 = SWIG_AsVal_double(args(0), &val1);
22219  if (!SWIG_IsOK(ecode1)) {
22220  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
22221  }
22222  arg1 = static_cast< PLFLT >(val1);
22223  plsdiori(arg1);
22224  _outv = octave_value();
22225  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22226  return _out;
22227 fail:
22228  return octave_value_list();
22229 }
22230 
22231 
22233  PLFLT arg1 ;
22234  PLFLT arg2 ;
22235  PLFLT arg3 ;
22236  PLFLT arg4 ;
22237  double val1 ;
22238  int ecode1 = 0 ;
22239  double val2 ;
22240  int ecode2 = 0 ;
22241  double val3 ;
22242  int ecode3 = 0 ;
22243  double val4 ;
22244  int ecode4 = 0 ;
22245  octave_value_list _out;
22246  octave_value_list *_outp=&_out;
22247  octave_value _outv;
22248 
22249  if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
22250  SWIG_fail;
22251  }
22252  ecode1 = SWIG_AsVal_double(args(0), &val1);
22253  if (!SWIG_IsOK(ecode1)) {
22254  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
22255  }
22256  arg1 = static_cast< PLFLT >(val1);
22257  ecode2 = SWIG_AsVal_double(args(1), &val2);
22258  if (!SWIG_IsOK(ecode2)) {
22259  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
22260  }
22261  arg2 = static_cast< PLFLT >(val2);
22262  ecode3 = SWIG_AsVal_double(args(2), &val3);
22263  if (!SWIG_IsOK(ecode3)) {
22264  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
22265  }
22266  arg3 = static_cast< PLFLT >(val3);
22267  ecode4 = SWIG_AsVal_double(args(3), &val4);
22268  if (!SWIG_IsOK(ecode4)) {
22269  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
22270  }
22271  arg4 = static_cast< PLFLT >(val4);
22272  plsdiplt(arg1,arg2,arg3,arg4);
22273  _outv = octave_value();
22274  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22275  return _out;
22276 fail:
22277  return octave_value_list();
22278 }
22279 
22280 
22282  PLFLT arg1 ;
22283  PLFLT arg2 ;
22284  PLFLT arg3 ;
22285  PLFLT arg4 ;
22286  double val1 ;
22287  int ecode1 = 0 ;
22288  double val2 ;
22289  int ecode2 = 0 ;
22290  double val3 ;
22291  int ecode3 = 0 ;
22292  double val4 ;
22293  int ecode4 = 0 ;
22294  octave_value_list _out;
22295  octave_value_list *_outp=&_out;
22296  octave_value _outv;
22297 
22298  if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
22299  SWIG_fail;
22300  }
22301  ecode1 = SWIG_AsVal_double(args(0), &val1);
22302  if (!SWIG_IsOK(ecode1)) {
22303  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
22304  }
22305  arg1 = static_cast< PLFLT >(val1);
22306  ecode2 = SWIG_AsVal_double(args(1), &val2);
22307  if (!SWIG_IsOK(ecode2)) {
22308  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
22309  }
22310  arg2 = static_cast< PLFLT >(val2);
22311  ecode3 = SWIG_AsVal_double(args(2), &val3);
22312  if (!SWIG_IsOK(ecode3)) {
22313  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
22314  }
22315  arg3 = static_cast< PLFLT >(val3);
22316  ecode4 = SWIG_AsVal_double(args(3), &val4);
22317  if (!SWIG_IsOK(ecode4)) {
22318  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
22319  }
22320  arg4 = static_cast< PLFLT >(val4);
22321  plsdiplz(arg1,arg2,arg3,arg4);
22322  _outv = octave_value();
22323  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22324  return _out;
22325 fail:
22326  return octave_value_list();
22327 }
22328 
22329 
22331  unsigned int arg1 ;
22332  unsigned int val1 ;
22333  int ecode1 = 0 ;
22334  octave_value_list _out;
22335  octave_value_list *_outp=&_out;
22336  octave_value _outv;
22337 
22338  if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
22339  SWIG_fail;
22340  }
22341  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
22342  if (!SWIG_IsOK(ecode1)) {
22343  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
22344  }
22345  arg1 = static_cast< unsigned int >(val1);
22346  plseed(arg1);
22347  _outv = octave_value();
22348  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22349  return _out;
22350 fail:
22351  return octave_value_list();
22352 }
22353 
22354 
22356  char arg1 ;
22357  char val1 ;
22358  int ecode1 = 0 ;
22359  octave_value_list _out;
22360  octave_value_list *_outp=&_out;
22361  octave_value _outv;
22362 
22363  if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
22364  SWIG_fail;
22365  }
22366  ecode1 = SWIG_AsVal_char(args(0), &val1);
22367  if (!SWIG_IsOK(ecode1)) {
22368  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
22369  }
22370  arg1 = static_cast< char >(val1);
22371  plsesc(arg1);
22372  _outv = octave_value();
22373  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22374  return _out;
22375 fail:
22376  return octave_value_list();
22377 }
22378 
22379 
22380 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
22381  char *arg1 = (char *) 0 ;
22382  char *arg2 = (char *) 0 ;
22383  int res1 ;
22384  char *buf1 = 0 ;
22385  int alloc1 = 0 ;
22386  int res2 ;
22387  char *buf2 = 0 ;
22388  int alloc2 = 0 ;
22389  octave_value_list _out;
22390  octave_value_list *_outp=&_out;
22391  octave_value _outv;
22392  PLINT result;
22393 
22394  if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
22395  SWIG_fail;
22396  }
22397  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22398  if (!SWIG_IsOK(res1)) {
22399  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
22400  }
22401  arg1 = reinterpret_cast< char * >(buf1);
22402  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22403  if (!SWIG_IsOK(res2)) {
22404  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
22405  }
22406  arg2 = reinterpret_cast< char * >(buf2);
22407  result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
22408  _outv = SWIG_From_int(static_cast< int >(result));
22409  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22410  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22411  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22412  return _out;
22413 fail:
22414  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22415  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22416  return octave_value_list();
22417 }
22418 
22419 
22421  PLINT arg1 ;
22422  PLINT arg2 ;
22423  PLINT arg3 ;
22424  int val1 ;
22425  int ecode1 = 0 ;
22426  int val2 ;
22427  int ecode2 = 0 ;
22428  int val3 ;
22429  int ecode3 = 0 ;
22430  octave_value_list _out;
22431  octave_value_list *_outp=&_out;
22432  octave_value _outv;
22433 
22434  if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
22435  SWIG_fail;
22436  }
22437  ecode1 = SWIG_AsVal_int(args(0), &val1);
22438  if (!SWIG_IsOK(ecode1)) {
22439  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
22440  }
22441  arg1 = static_cast< PLINT >(val1);
22442  ecode2 = SWIG_AsVal_int(args(1), &val2);
22443  if (!SWIG_IsOK(ecode2)) {
22444  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
22445  }
22446  arg2 = static_cast< PLINT >(val2);
22447  ecode3 = SWIG_AsVal_int(args(2), &val3);
22448  if (!SWIG_IsOK(ecode3)) {
22449  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
22450  }
22451  arg3 = static_cast< PLINT >(val3);
22452  plsfam(arg1,arg2,arg3);
22453  _outv = octave_value();
22454  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22455  return _out;
22456 fail:
22457  return octave_value_list();
22458 }
22459 
22460 
22462  PLUNICODE arg1 ;
22463  unsigned int val1 ;
22464  int ecode1 = 0 ;
22465  octave_value_list _out;
22466  octave_value_list *_outp=&_out;
22467  octave_value _outv;
22468 
22469  if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
22470  SWIG_fail;
22471  }
22472  ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
22473  if (!SWIG_IsOK(ecode1)) {
22474  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
22475  }
22476  arg1 = static_cast< PLUNICODE >(val1);
22477  plsfci(arg1);
22478  _outv = octave_value();
22479  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22480  return _out;
22481 fail:
22482  return octave_value_list();
22483 }
22484 
22485 
22487  char *arg1 = (char *) 0 ;
22488  int res1 ;
22489  char *buf1 = 0 ;
22490  int alloc1 = 0 ;
22491  octave_value_list _out;
22492  octave_value_list *_outp=&_out;
22493  octave_value _outv;
22494 
22495  if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
22496  SWIG_fail;
22497  }
22498  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22499  if (!SWIG_IsOK(res1)) {
22500  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
22501  }
22502  arg1 = reinterpret_cast< char * >(buf1);
22503  plsfnam((char const *)arg1);
22504  _outv = octave_value();
22505  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22506  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22507  return _out;
22508 fail:
22509  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22510  return octave_value_list();
22511 }
22512 
22513 
22515  PLINT arg1 ;
22516  PLINT arg2 ;
22517  PLINT arg3 ;
22518  int val1 ;
22519  int ecode1 = 0 ;
22520  int val2 ;
22521  int ecode2 = 0 ;
22522  int val3 ;
22523  int ecode3 = 0 ;
22524  octave_value_list _out;
22525  octave_value_list *_outp=&_out;
22526  octave_value _outv;
22527 
22528  if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
22529  SWIG_fail;
22530  }
22531  ecode1 = SWIG_AsVal_int(args(0), &val1);
22532  if (!SWIG_IsOK(ecode1)) {
22533  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
22534  }
22535  arg1 = static_cast< PLINT >(val1);
22536  ecode2 = SWIG_AsVal_int(args(1), &val2);
22537  if (!SWIG_IsOK(ecode2)) {
22538  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
22539  }
22540  arg2 = static_cast< PLINT >(val2);
22541  ecode3 = SWIG_AsVal_int(args(2), &val3);
22542  if (!SWIG_IsOK(ecode3)) {
22543  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
22544  }
22545  arg3 = static_cast< PLINT >(val3);
22546  plsfont(arg1,arg2,arg3);
22547  _outv = octave_value();
22548  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22549  return _out;
22550 fail:
22551  return octave_value_list();
22552 }
22553 
22554 
22556  label_func arg1 = (label_func) 0 ;
22557  PLPointer arg2 = (PLPointer) 0 ;
22558  int res2 ;
22559  octave_value_list _out;
22560  octave_value_list *_outp=&_out;
22561  octave_value _outv;
22562 
22563  if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
22564  SWIG_fail;
22565  }
22566  {
22567  octave_value obj = args(0);
22568 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
22569  if ( !obj.isempty() )
22570 #else
22571  if ( !obj.is_empty() )
22572 #endif
22573  {
22574  if ( obj.is_function_handle() || obj.is_inline_function() )
22575  {
22576  fcnLabelFunc = obj.function_value();
22577  }
22578  else if ( obj.is_string() )
22579  {
22580  nameLabelFunc = obj.string_value();
22581  fcnLabelFunc = NULL;
22582  }
22583  arg1 = labelfunc_octave;
22584  }
22585  else
22586  {
22587  arg1 = NULL;
22588  }
22589  }
22590  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
22591  if (!SWIG_IsOK(res2)) {
22592  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
22593  }
22594  plslabelfunc(arg1,arg2);
22595  _outv = octave_value();
22596  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22597  return _out;
22598 fail:
22599  return octave_value_list();
22600 }
22601 
22602 
22604  PLFLT arg1 ;
22605  PLFLT arg2 ;
22606  double val1 ;
22607  int ecode1 = 0 ;
22608  double val2 ;
22609  int ecode2 = 0 ;
22610  octave_value_list _out;
22611  octave_value_list *_outp=&_out;
22612  octave_value _outv;
22613 
22614  if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
22615  SWIG_fail;
22616  }
22617  ecode1 = SWIG_AsVal_double(args(0), &val1);
22618  if (!SWIG_IsOK(ecode1)) {
22619  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
22620  }
22621  arg1 = static_cast< PLFLT >(val1);
22622  ecode2 = SWIG_AsVal_double(args(1), &val2);
22623  if (!SWIG_IsOK(ecode2)) {
22624  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
22625  }
22626  arg2 = static_cast< PLFLT >(val2);
22627  plsmaj(arg1,arg2);
22628  _outv = octave_value();
22629  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22630  return _out;
22631 fail:
22632  return octave_value_list();
22633 }
22634 
22635 
22637  PLFLT arg1 ;
22638  PLFLT arg2 ;
22639  double val1 ;
22640  int ecode1 = 0 ;
22641  double val2 ;
22642  int ecode2 = 0 ;
22643  octave_value_list _out;
22644  octave_value_list *_outp=&_out;
22645  octave_value _outv;
22646 
22647  if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
22648  SWIG_fail;
22649  }
22650  ecode1 = SWIG_AsVal_double(args(0), &val1);
22651  if (!SWIG_IsOK(ecode1)) {
22652  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
22653  }
22654  arg1 = static_cast< PLFLT >(val1);
22655  ecode2 = SWIG_AsVal_double(args(1), &val2);
22656  if (!SWIG_IsOK(ecode2)) {
22657  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
22658  }
22659  arg2 = static_cast< PLFLT >(val2);
22660  plsmin(arg1,arg2);
22661  _outv = octave_value();
22662  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22663  return _out;
22664 fail:
22665  return octave_value_list();
22666 }
22667 
22668 
22670  PLINT arg1 ;
22671  int val1 ;
22672  int ecode1 = 0 ;
22673  octave_value_list _out;
22674  octave_value_list *_outp=&_out;
22675  octave_value _outv;
22676 
22677  if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
22678  SWIG_fail;
22679  }
22680  ecode1 = SWIG_AsVal_int(args(0), &val1);
22681  if (!SWIG_IsOK(ecode1)) {
22682  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
22683  }
22684  arg1 = static_cast< PLINT >(val1);
22685  plsori(arg1);
22686  _outv = octave_value();
22687  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22688  return _out;
22689 fail:
22690  return octave_value_list();
22691 }
22692 
22693 
22695  PLFLT arg1 ;
22696  PLFLT arg2 ;
22697  PLINT arg3 ;
22698  PLINT arg4 ;
22699  PLINT arg5 ;
22700  PLINT arg6 ;
22701  double val1 ;
22702  int ecode1 = 0 ;
22703  double val2 ;
22704  int ecode2 = 0 ;
22705  int val3 ;
22706  int ecode3 = 0 ;
22707  int val4 ;
22708  int ecode4 = 0 ;
22709  int val5 ;
22710  int ecode5 = 0 ;
22711  int val6 ;
22712  int ecode6 = 0 ;
22713  octave_value_list _out;
22714  octave_value_list *_outp=&_out;
22715  octave_value _outv;
22716 
22717  if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
22718  SWIG_fail;
22719  }
22720  ecode1 = SWIG_AsVal_double(args(0), &val1);
22721  if (!SWIG_IsOK(ecode1)) {
22722  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
22723  }
22724  arg1 = static_cast< PLFLT >(val1);
22725  ecode2 = SWIG_AsVal_double(args(1), &val2);
22726  if (!SWIG_IsOK(ecode2)) {
22727  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
22728  }
22729  arg2 = static_cast< PLFLT >(val2);
22730  ecode3 = SWIG_AsVal_int(args(2), &val3);
22731  if (!SWIG_IsOK(ecode3)) {
22732  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
22733  }
22734  arg3 = static_cast< PLINT >(val3);
22735  ecode4 = SWIG_AsVal_int(args(3), &val4);
22736  if (!SWIG_IsOK(ecode4)) {
22737  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
22738  }
22739  arg4 = static_cast< PLINT >(val4);
22740  ecode5 = SWIG_AsVal_int(args(4), &val5);
22741  if (!SWIG_IsOK(ecode5)) {
22742  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
22743  }
22744  arg5 = static_cast< PLINT >(val5);
22745  ecode6 = SWIG_AsVal_int(args(5), &val6);
22746  if (!SWIG_IsOK(ecode6)) {
22747  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
22748  }
22749  arg6 = static_cast< PLINT >(val6);
22750  plspage(arg1,arg2,arg3,arg4,arg5,arg6);
22751  _outv = octave_value();
22752  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22753  return _out;
22754 fail:
22755  return octave_value_list();
22756 }
22757 
22758 
22760  char *arg1 = (char *) 0 ;
22761  int res1 ;
22762  char *buf1 = 0 ;
22763  int alloc1 = 0 ;
22764  octave_value_list _out;
22765  octave_value_list *_outp=&_out;
22766  octave_value _outv;
22767 
22768  if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
22769  SWIG_fail;
22770  }
22771  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22772  if (!SWIG_IsOK(res1)) {
22773  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
22774  }
22775  arg1 = reinterpret_cast< char * >(buf1);
22776  plspal0((char const *)arg1);
22777  _outv = octave_value();
22778  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22779  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22780  return _out;
22781 fail:
22782  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22783  return octave_value_list();
22784 }
22785 
22786 
22788  char *arg1 = (char *) 0 ;
22789  PLBOOL arg2 ;
22790  int res1 ;
22791  char *buf1 = 0 ;
22792  int alloc1 = 0 ;
22793  int val2 ;
22794  int ecode2 = 0 ;
22795  octave_value_list _out;
22796  octave_value_list *_outp=&_out;
22797  octave_value _outv;
22798 
22799  if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
22800  SWIG_fail;
22801  }
22802  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22803  if (!SWIG_IsOK(res1)) {
22804  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
22805  }
22806  arg1 = reinterpret_cast< char * >(buf1);
22807  ecode2 = SWIG_AsVal_int(args(1), &val2);
22808  if (!SWIG_IsOK(ecode2)) {
22809  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
22810  }
22811  arg2 = static_cast< PLBOOL >(val2);
22812  plspal1((char const *)arg1,arg2);
22813  _outv = octave_value();
22814  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22815  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22816  return _out;
22817 fail:
22818  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22819  return octave_value_list();
22820 }
22821 
22822 
22824  PLBOOL arg1 ;
22825  int val1 ;
22826  int ecode1 = 0 ;
22827  octave_value_list _out;
22828  octave_value_list *_outp=&_out;
22829  octave_value _outv;
22830 
22831  if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
22832  SWIG_fail;
22833  }
22834  ecode1 = SWIG_AsVal_int(args(0), &val1);
22835  if (!SWIG_IsOK(ecode1)) {
22836  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
22837  }
22838  arg1 = static_cast< PLBOOL >(val1);
22839  plspause(arg1);
22840  _outv = octave_value();
22841  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22842  return _out;
22843 fail:
22844  return octave_value_list();
22845 }
22846 
22847 
22849  PLINT arg1 ;
22850  int val1 ;
22851  int ecode1 = 0 ;
22852  octave_value_list _out;
22853  octave_value_list *_outp=&_out;
22854  octave_value _outv;
22855 
22856  if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
22857  SWIG_fail;
22858  }
22859  ecode1 = SWIG_AsVal_int(args(0), &val1);
22860  if (!SWIG_IsOK(ecode1)) {
22861  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
22862  }
22863  arg1 = static_cast< PLINT >(val1);
22864  plsstrm(arg1);
22865  _outv = octave_value();
22866  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22867  return _out;
22868 fail:
22869  return octave_value_list();
22870 }
22871 
22872 
22874  PLINT arg1 ;
22875  PLINT arg2 ;
22876  int val1 ;
22877  int ecode1 = 0 ;
22878  int val2 ;
22879  int ecode2 = 0 ;
22880  octave_value_list _out;
22881  octave_value_list *_outp=&_out;
22882  octave_value _outv;
22883 
22884  if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
22885  SWIG_fail;
22886  }
22887  ecode1 = SWIG_AsVal_int(args(0), &val1);
22888  if (!SWIG_IsOK(ecode1)) {
22889  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
22890  }
22891  arg1 = static_cast< PLINT >(val1);
22892  ecode2 = SWIG_AsVal_int(args(1), &val2);
22893  if (!SWIG_IsOK(ecode2)) {
22894  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
22895  }
22896  arg2 = static_cast< PLINT >(val2);
22897  plssub(arg1,arg2);
22898  _outv = octave_value();
22899  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22900  return _out;
22901 fail:
22902  return octave_value_list();
22903 }
22904 
22905 
22907  PLFLT arg1 ;
22908  PLFLT arg2 ;
22909  double val1 ;
22910  int ecode1 = 0 ;
22911  double val2 ;
22912  int ecode2 = 0 ;
22913  octave_value_list _out;
22914  octave_value_list *_outp=&_out;
22915  octave_value _outv;
22916 
22917  if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
22918  SWIG_fail;
22919  }
22920  ecode1 = SWIG_AsVal_double(args(0), &val1);
22921  if (!SWIG_IsOK(ecode1)) {
22922  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
22923  }
22924  arg1 = static_cast< PLFLT >(val1);
22925  ecode2 = SWIG_AsVal_double(args(1), &val2);
22926  if (!SWIG_IsOK(ecode2)) {
22927  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
22928  }
22929  arg2 = static_cast< PLFLT >(val2);
22930  plssym(arg1,arg2);
22931  _outv = octave_value();
22932  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22933  return _out;
22934 fail:
22935  return octave_value_list();
22936 }
22937 
22938 
22940  PLINT arg1 ;
22941  PLINT arg2 ;
22942  int val1 ;
22943  int ecode1 = 0 ;
22944  int val2 ;
22945  int ecode2 = 0 ;
22946  octave_value_list _out;
22947  octave_value_list *_outp=&_out;
22948  octave_value _outv;
22949 
22950  if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
22951  SWIG_fail;
22952  }
22953  ecode1 = SWIG_AsVal_int(args(0), &val1);
22954  if (!SWIG_IsOK(ecode1)) {
22955  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
22956  }
22957  arg1 = static_cast< PLINT >(val1);
22958  ecode2 = SWIG_AsVal_int(args(1), &val2);
22959  if (!SWIG_IsOK(ecode2)) {
22960  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
22961  }
22962  arg2 = static_cast< PLINT >(val2);
22963  plstar(arg1,arg2);
22964  _outv = octave_value();
22965  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22966  return _out;
22967 fail:
22968  return octave_value_list();
22969 }
22970 
22971 
22973  char *arg1 = (char *) 0 ;
22974  PLINT arg2 ;
22975  PLINT arg3 ;
22976  int res1 ;
22977  char *buf1 = 0 ;
22978  int alloc1 = 0 ;
22979  int val2 ;
22980  int ecode2 = 0 ;
22981  int val3 ;
22982  int ecode3 = 0 ;
22983  octave_value_list _out;
22984  octave_value_list *_outp=&_out;
22985  octave_value _outv;
22986 
22987  if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
22988  SWIG_fail;
22989  }
22990  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22991  if (!SWIG_IsOK(res1)) {
22992  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
22993  }
22994  arg1 = reinterpret_cast< char * >(buf1);
22995  ecode2 = SWIG_AsVal_int(args(1), &val2);
22996  if (!SWIG_IsOK(ecode2)) {
22997  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
22998  }
22999  arg2 = static_cast< PLINT >(val2);
23000  ecode3 = SWIG_AsVal_int(args(2), &val3);
23001  if (!SWIG_IsOK(ecode3)) {
23002  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
23003  }
23004  arg3 = static_cast< PLINT >(val3);
23005  plstart((char const *)arg1,arg2,arg3);
23006  _outv = octave_value();
23007  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23008  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23009  return _out;
23010 fail:
23011  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23012  return octave_value_list();
23013 }
23014 
23015 
23017  ct_func arg1 = (ct_func) 0 ;
23018  PLPointer arg2 = (PLPointer) 0 ;
23019  int res2 ;
23020  octave_value_list _out;
23021  octave_value_list *_outp=&_out;
23022  octave_value _outv;
23023 
23024  if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
23025  SWIG_fail;
23026  }
23027  {
23028  octave_value obj = args(0);
23029 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23030  if ( !obj.isempty() )
23031 #else
23032  if ( !obj.is_empty() )
23033 #endif
23034  {
23035  if ( obj.is_function_handle() || obj.is_inline_function() )
23036  {
23037  fcnCoordTrans = obj.function_value();
23038  }
23039  else if ( obj.is_string() )
23040  {
23041  nameCoordTrans = obj.string_value();
23042  fcnCoordTrans = NULL;
23043  }
23044  arg1 = ct_octave;
23045  }
23046  else
23047  {
23048  arg1 = NULL;
23049  }
23050  }
23051  res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
23052  if (!SWIG_IsOK(res2)) {
23053  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
23054  }
23055  plstransform(arg1,arg2);
23056  _outv = octave_value();
23057  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23058  return _out;
23059 fail:
23060  return octave_value_list();
23061 }
23062 
23063 
23065  PLINT arg1 ;
23066  PLFLT *arg2 = (PLFLT *) 0 ;
23067  PLFLT *arg3 = (PLFLT *) 0 ;
23068  char *arg4 = (char *) 0 ;
23069  Matrix temp1 ;
23070  Matrix temp3 ;
23071  int res4 ;
23072  char *buf4 = 0 ;
23073  int alloc4 = 0 ;
23074  octave_value_list _out;
23075  octave_value_list *_outp=&_out;
23076  octave_value _outv;
23077 
23078  if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
23079  SWIG_fail;
23080  }
23081  {
23082  if ( _n_dims( args(0) ) > 1 )
23083  {
23084  error( "argument must be a scalar or vector" ); SWIG_fail;
23085  }
23086  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23087  temp1 = args(0).matrix_value();
23088  arg2 = &temp1( 0, 0 );
23089  }
23090  {
23091  if ( _n_dims( args(1) ) > 1 )
23092  {
23093  error( "argument must be a scalar or vector" ); SWIG_fail;
23094  }
23095  if ( _dim( args(1), 0 ) != Alen )
23096  {
23097  error( "argument vectors must be same length" ); SWIG_fail;
23098  }
23099  temp3 = args(1).matrix_value();
23100  arg3 = &temp3( 0, 0 );
23101  }
23102  res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
23103  if (!SWIG_IsOK(res4)) {
23104  SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
23105  }
23106  arg4 = reinterpret_cast< char * >(buf4);
23107  plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
23108  _outv = octave_value();
23109  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23110  {
23111 
23112  }
23113  {
23114 
23115  }
23116  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
23117  return _out;
23118 fail:
23119  {
23120 
23121  }
23122  {
23123 
23124  }
23125  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
23126  return octave_value_list();
23127 }
23128 
23129 
23131  PLINT arg1 ;
23132  PLFLT *arg2 = (PLFLT *) 0 ;
23133  PLFLT *arg3 = (PLFLT *) 0 ;
23134  PLFLT *arg4 = (PLFLT *) 0 ;
23135  char *arg5 = (char *) 0 ;
23136  Matrix temp1 ;
23137  Matrix temp3 ;
23138  Matrix temp4 ;
23139  int res5 ;
23140  char *buf5 = 0 ;
23141  int alloc5 = 0 ;
23142  octave_value_list _out;
23143  octave_value_list *_outp=&_out;
23144  octave_value _outv;
23145 
23146  if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
23147  SWIG_fail;
23148  }
23149  {
23150  if ( _n_dims( args(0) ) > 1 )
23151  {
23152  error( "argument must be a scalar or vector" ); SWIG_fail;
23153  }
23154  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23155  temp1 = args(0).matrix_value();
23156  arg2 = &temp1( 0, 0 );
23157  }
23158  {
23159  if ( _n_dims( args(1) ) > 1 )
23160  {
23161  error( "argument must be a scalar or vector" ); SWIG_fail;
23162  }
23163  if ( _dim( args(1), 0 ) != Alen )
23164  {
23165  error( "argument vectors must be same length" ); SWIG_fail;
23166  }
23167  temp3 = args(1).matrix_value();
23168  arg3 = &temp3( 0, 0 );
23169  }
23170  {
23171  if ( _n_dims( args(2) ) > 1 )
23172  {
23173  error( "argument must be a scalar or vector" ); SWIG_fail;
23174  }
23175  if ( _dim( args(2), 0 ) != Alen )
23176  {
23177  error( "argument vectors must be same length" ); SWIG_fail;
23178  }
23179  temp4 = args(2).matrix_value();
23180  arg4 = &temp4( 0, 0 );
23181  }
23182  res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
23183  if (!SWIG_IsOK(res5)) {
23184  SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
23185  }
23186  arg5 = reinterpret_cast< char * >(buf5);
23187  plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
23188  _outv = octave_value();
23189  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23190  {
23191 
23192  }
23193  {
23194 
23195  }
23196  {
23197 
23198  }
23199  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
23200  return _out;
23201 fail:
23202  {
23203 
23204  }
23205  {
23206 
23207  }
23208  {
23209 
23210  }
23211  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
23212  return octave_value_list();
23213 }
23214 
23215 
23217  PLINT arg1 ;
23218  PLINT arg2 ;
23219  PLFLT arg3 ;
23220  PLFLT arg4 ;
23221  int val1 ;
23222  int ecode1 = 0 ;
23223  int val2 ;
23224  int ecode2 = 0 ;
23225  double val3 ;
23226  int ecode3 = 0 ;
23227  double val4 ;
23228  int ecode4 = 0 ;
23229  octave_value_list _out;
23230  octave_value_list *_outp=&_out;
23231  octave_value _outv;
23232 
23233  if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
23234  SWIG_fail;
23235  }
23236  ecode1 = SWIG_AsVal_int(args(0), &val1);
23237  if (!SWIG_IsOK(ecode1)) {
23238  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
23239  }
23240  arg1 = static_cast< PLINT >(val1);
23241  ecode2 = SWIG_AsVal_int(args(1), &val2);
23242  if (!SWIG_IsOK(ecode2)) {
23243  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
23244  }
23245  arg2 = static_cast< PLINT >(val2);
23246  ecode3 = SWIG_AsVal_double(args(2), &val3);
23247  if (!SWIG_IsOK(ecode3)) {
23248  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
23249  }
23250  arg3 = static_cast< PLFLT >(val3);
23251  ecode4 = SWIG_AsVal_double(args(3), &val4);
23252  if (!SWIG_IsOK(ecode4)) {
23253  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
23254  }
23255  arg4 = static_cast< PLFLT >(val4);
23256  plstripa(arg1,arg2,arg3,arg4);
23257  _outv = octave_value();
23258  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23259  return _out;
23260 fail:
23261  return octave_value_list();
23262 }
23263 
23264 
23266  PLINT arg1 ;
23267  int val1 ;
23268  int ecode1 = 0 ;
23269  octave_value_list _out;
23270  octave_value_list *_outp=&_out;
23271  octave_value _outv;
23272 
23273  if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
23274  SWIG_fail;
23275  }
23276  ecode1 = SWIG_AsVal_int(args(0), &val1);
23277  if (!SWIG_IsOK(ecode1)) {
23278  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
23279  }
23280  arg1 = static_cast< PLINT >(val1);
23281  plstripd(arg1);
23282  _outv = octave_value();
23283  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23284  return _out;
23285 fail:
23286  return octave_value_list();
23287 }
23288 
23289 
23291  PLINT arg1 ;
23292  PLINT *arg2 = (PLINT *) 0 ;
23293  PLINT *arg3 = (PLINT *) 0 ;
23294  Matrix temp1 ;
23295  Matrix temp3 ;
23296  octave_value_list _out;
23297  octave_value_list *_outp=&_out;
23298  octave_value _outv;
23299 
23300  if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
23301  SWIG_fail;
23302  }
23303  {
23304  if ( _n_dims( args(0) ) > 1 )
23305  {
23306  error( "argument must be a scalar or vector" ); SWIG_fail;
23307  }
23308  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23309  arg2 = new PLINT[Alen];
23310  temp1 = args(0).matrix_value();
23311  _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
23312  }
23313  {
23314  if ( _n_dims( args(1) ) > 1 )
23315  {
23316  error( "argument must be a scalar or vector" ); SWIG_fail;
23317  }
23318  if ( _dim( args(1), 0 ) != Alen )
23319  {
23320  error( "argument vectors must be same length" ); SWIG_fail;
23321  }
23322  temp3 = args(1).matrix_value();
23323  arg3 = new PLINT[Alen];
23324  _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
23325  }
23326  plstyl(arg1,(int const *)arg2,(int const *)arg3);
23327  _outv = octave_value();
23328  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23329  {
23330  delete [] arg2;
23331  }
23332  {
23333  delete [] arg3;
23334  }
23335  return _out;
23336 fail:
23337  {
23338  delete [] arg2;
23339  }
23340  {
23341  delete [] arg3;
23342  }
23343  return octave_value_list();
23344 }
23345 
23346 
23348  PLFLT *arg1 = (PLFLT *) 0 ;
23349  PLFLT *arg2 = (PLFLT *) 0 ;
23350  PLINT arg3 ;
23351  PLBOOL arg4 ;
23352  Matrix temp1 ;
23353  Matrix temp2 ;
23354  int val4 ;
23355  int ecode4 = 0 ;
23356  octave_value_list _out;
23357  octave_value_list *_outp=&_out;
23358  octave_value _outv;
23359 
23360  if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
23361  SWIG_fail;
23362  }
23363  {
23364  if ( _n_dims( args(0) ) > 1 )
23365  {
23366  error( "argument must be a scalar or vector" ); SWIG_fail;
23367  }
23368 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23369  if ( !args(0).isempty() )
23370 #else
23371  if ( !args(0).is_empty() )
23372 #endif
23373  {
23374  Alen = (PLINT) ( _dim( args(0), 0 ) );
23375  temp1 = args(0).matrix_value();
23376  arg1 = &temp1( 0, 0 );
23377  }
23378  else
23379  {
23380  arg1 = NULL;
23381  Alen = 0;
23382  }
23383  }
23384  {
23385  if ( _n_dims( args(1) ) > 1 )
23386  {
23387  error( "argument must be a scalar or vector" ); SWIG_fail;
23388  }
23389 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23390  if ( !args(1).isempty() )
23391 #else
23392  if ( !args(1).is_empty() )
23393 #endif
23394  {
23395  if ( _dim( args(1), 0 ) != Alen )
23396  {
23397  error( "argument vectors must be same length" ); SWIG_fail;
23398  }
23399  temp2 = args(1).matrix_value();
23400  arg2 = &temp2( 0, 0 );
23401  arg3 = (PLINT) ( _dim( args(1), 0 ) );
23402  }
23403  else
23404  {
23405  arg2 = NULL;
23406  arg3 = 0;
23407  }
23408  }
23409  ecode4 = SWIG_AsVal_int(args(2), &val4);
23410  if (!SWIG_IsOK(ecode4)) {
23411  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
23412  }
23413  arg4 = static_cast< PLBOOL >(val4);
23414  plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
23415  _outv = octave_value();
23416  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23417  {
23418 
23419  }
23420  {
23421 
23422  }
23423  return _out;
23424 fail:
23425  {
23426 
23427  }
23428  {
23429 
23430  }
23431  return octave_value_list();
23432 }
23433 
23434 
23436  PLFLT arg1 ;
23437  PLFLT arg2 ;
23438  PLFLT arg3 ;
23439  PLFLT arg4 ;
23440  double val1 ;
23441  int ecode1 = 0 ;
23442  double val2 ;
23443  int ecode2 = 0 ;
23444  double val3 ;
23445  int ecode3 = 0 ;
23446  double val4 ;
23447  int ecode4 = 0 ;
23448  octave_value_list _out;
23449  octave_value_list *_outp=&_out;
23450  octave_value _outv;
23451 
23452  if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
23453  SWIG_fail;
23454  }
23455  ecode1 = SWIG_AsVal_double(args(0), &val1);
23456  if (!SWIG_IsOK(ecode1)) {
23457  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
23458  }
23459  arg1 = static_cast< PLFLT >(val1);
23460  ecode2 = SWIG_AsVal_double(args(1), &val2);
23461  if (!SWIG_IsOK(ecode2)) {
23462  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
23463  }
23464  arg2 = static_cast< PLFLT >(val2);
23465  ecode3 = SWIG_AsVal_double(args(2), &val3);
23466  if (!SWIG_IsOK(ecode3)) {
23467  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
23468  }
23469  arg3 = static_cast< PLFLT >(val3);
23470  ecode4 = SWIG_AsVal_double(args(3), &val4);
23471  if (!SWIG_IsOK(ecode4)) {
23472  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
23473  }
23474  arg4 = static_cast< PLFLT >(val4);
23475  plsvpa(arg1,arg2,arg3,arg4);
23476  _outv = octave_value();
23477  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23478  return _out;
23479 fail:
23480  return octave_value_list();
23481 }
23482 
23483 
23485  PLINT arg1 ;
23486  PLINT arg2 ;
23487  int val1 ;
23488  int ecode1 = 0 ;
23489  int val2 ;
23490  int ecode2 = 0 ;
23491  octave_value_list _out;
23492  octave_value_list *_outp=&_out;
23493  octave_value _outv;
23494 
23495  if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
23496  SWIG_fail;
23497  }
23498  ecode1 = SWIG_AsVal_int(args(0), &val1);
23499  if (!SWIG_IsOK(ecode1)) {
23500  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
23501  }
23502  arg1 = static_cast< PLINT >(val1);
23503  ecode2 = SWIG_AsVal_int(args(1), &val2);
23504  if (!SWIG_IsOK(ecode2)) {
23505  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
23506  }
23507  arg2 = static_cast< PLINT >(val2);
23508  plsxax(arg1,arg2);
23509  _outv = octave_value();
23510  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23511  return _out;
23512 fail:
23513  return octave_value_list();
23514 }
23515 
23516 
23518  PLINT arg1 ;
23519  PLINT arg2 ;
23520  int val1 ;
23521  int ecode1 = 0 ;
23522  int val2 ;
23523  int ecode2 = 0 ;
23524  octave_value_list _out;
23525  octave_value_list *_outp=&_out;
23526  octave_value _outv;
23527 
23528  if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
23529  SWIG_fail;
23530  }
23531  ecode1 = SWIG_AsVal_int(args(0), &val1);
23532  if (!SWIG_IsOK(ecode1)) {
23533  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
23534  }
23535  arg1 = static_cast< PLINT >(val1);
23536  ecode2 = SWIG_AsVal_int(args(1), &val2);
23537  if (!SWIG_IsOK(ecode2)) {
23538  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
23539  }
23540  arg2 = static_cast< PLINT >(val2);
23541  plsyax(arg1,arg2);
23542  _outv = octave_value();
23543  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23544  return _out;
23545 fail:
23546  return octave_value_list();
23547 }
23548 
23549 
23551  PLINT arg1 ;
23552  PLFLT *arg2 = (PLFLT *) 0 ;
23553  PLFLT *arg3 = (PLFLT *) 0 ;
23554  PLINT arg4 ;
23555  Matrix temp1 ;
23556  Matrix temp3 ;
23557  int val4 ;
23558  int ecode4 = 0 ;
23559  octave_value_list _out;
23560  octave_value_list *_outp=&_out;
23561  octave_value _outv;
23562 
23563  if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
23564  SWIG_fail;
23565  }
23566  {
23567  if ( _n_dims( args(0) ) > 1 )
23568  {
23569  error( "argument must be a scalar or vector" ); SWIG_fail;
23570  }
23571  arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23572  temp1 = args(0).matrix_value();
23573  arg2 = &temp1( 0, 0 );
23574  }
23575  {
23576  if ( _n_dims( args(1) ) > 1 )
23577  {
23578  error( "argument must be a scalar or vector" ); SWIG_fail;
23579  }
23580  if ( _dim( args(1), 0 ) != Alen )
23581  {
23582  error( "argument vectors must be same length" ); SWIG_fail;
23583  }
23584  temp3 = args(1).matrix_value();
23585  arg3 = &temp3( 0, 0 );
23586  }
23587  ecode4 = SWIG_AsVal_int(args(2), &val4);
23588  if (!SWIG_IsOK(ecode4)) {
23589  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
23590  }
23591  arg4 = static_cast< PLINT >(val4);
23592  plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
23593  _outv = octave_value();
23594  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23595  {
23596 
23597  }
23598  {
23599 
23600  }
23601  return _out;
23602 fail:
23603  {
23604 
23605  }
23606  {
23607 
23608  }
23609  return octave_value_list();
23610 }
23611 
23612 
23614  PLINT arg1 ;
23615  PLINT arg2 ;
23616  int val1 ;
23617  int ecode1 = 0 ;
23618  int val2 ;
23619  int ecode2 = 0 ;
23620  octave_value_list _out;
23621  octave_value_list *_outp=&_out;
23622  octave_value _outv;
23623 
23624  if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
23625  SWIG_fail;
23626  }
23627  ecode1 = SWIG_AsVal_int(args(0), &val1);
23628  if (!SWIG_IsOK(ecode1)) {
23629  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
23630  }
23631  arg1 = static_cast< PLINT >(val1);
23632  ecode2 = SWIG_AsVal_int(args(1), &val2);
23633  if (!SWIG_IsOK(ecode2)) {
23634  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
23635  }
23636  arg2 = static_cast< PLINT >(val2);
23637  plszax(arg1,arg2);
23638  _outv = octave_value();
23639  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23640  return _out;
23641 fail:
23642  return octave_value_list();
23643 }
23644 
23645 
23647  octave_value_list _out;
23648  octave_value_list *_outp=&_out;
23649  octave_value _outv;
23650 
23651  if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
23652  SWIG_fail;
23653  }
23654  pltext();
23655  _outv = octave_value();
23656  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23657  return _out;
23658 fail:
23659  return octave_value_list();
23660 }
23661 
23662 
23664  char *arg1 = (char *) 0 ;
23665  int res1 ;
23666  char *buf1 = 0 ;
23667  int alloc1 = 0 ;
23668  octave_value_list _out;
23669  octave_value_list *_outp=&_out;
23670  octave_value _outv;
23671 
23672  if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
23673  SWIG_fail;
23674  }
23675  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23676  if (!SWIG_IsOK(res1)) {
23677  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
23678  }
23679  arg1 = reinterpret_cast< char * >(buf1);
23680  pltimefmt((char const *)arg1);
23681  _outv = octave_value();
23682  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23683  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23684  return _out;
23685 fail:
23686  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23687  return octave_value_list();
23688 }
23689 
23690 
23692  PLFLT arg1 ;
23693  double val1 ;
23694  int ecode1 = 0 ;
23695  octave_value_list _out;
23696  octave_value_list *_outp=&_out;
23697  octave_value _outv;
23698 
23699  if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
23700  SWIG_fail;
23701  }
23702  ecode1 = SWIG_AsVal_double(args(0), &val1);
23703  if (!SWIG_IsOK(ecode1)) {
23704  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
23705  }
23706  arg1 = static_cast< PLFLT >(val1);
23707  plvasp(arg1);
23708  _outv = octave_value();
23709  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23710  return _out;
23711 fail:
23712  return octave_value_list();
23713 }
23714 
23715 
23717  PLFLT arg1 ;
23718  PLFLT arg2 ;
23719  PLFLT arg3 ;
23720  PLFLT arg4 ;
23721  PLFLT arg5 ;
23722  double val1 ;
23723  int ecode1 = 0 ;
23724  double val2 ;
23725  int ecode2 = 0 ;
23726  double val3 ;
23727  int ecode3 = 0 ;
23728  double val4 ;
23729  int ecode4 = 0 ;
23730  double val5 ;
23731  int ecode5 = 0 ;
23732  octave_value_list _out;
23733  octave_value_list *_outp=&_out;
23734  octave_value _outv;
23735 
23736  if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
23737  SWIG_fail;
23738  }
23739  ecode1 = SWIG_AsVal_double(args(0), &val1);
23740  if (!SWIG_IsOK(ecode1)) {
23741  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
23742  }
23743  arg1 = static_cast< PLFLT >(val1);
23744  ecode2 = SWIG_AsVal_double(args(1), &val2);
23745  if (!SWIG_IsOK(ecode2)) {
23746  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
23747  }
23748  arg2 = static_cast< PLFLT >(val2);
23749  ecode3 = SWIG_AsVal_double(args(2), &val3);
23750  if (!SWIG_IsOK(ecode3)) {
23751  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
23752  }
23753  arg3 = static_cast< PLFLT >(val3);
23754  ecode4 = SWIG_AsVal_double(args(3), &val4);
23755  if (!SWIG_IsOK(ecode4)) {
23756  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
23757  }
23758  arg4 = static_cast< PLFLT >(val4);
23759  ecode5 = SWIG_AsVal_double(args(4), &val5);
23760  if (!SWIG_IsOK(ecode5)) {
23761  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
23762  }
23763  arg5 = static_cast< PLFLT >(val5);
23764  plvpas(arg1,arg2,arg3,arg4,arg5);
23765  _outv = octave_value();
23766  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23767  return _out;
23768 fail:
23769  return octave_value_list();
23770 }
23771 
23772 
23774  PLFLT arg1 ;
23775  PLFLT arg2 ;
23776  PLFLT arg3 ;
23777  PLFLT arg4 ;
23778  double val1 ;
23779  int ecode1 = 0 ;
23780  double val2 ;
23781  int ecode2 = 0 ;
23782  double val3 ;
23783  int ecode3 = 0 ;
23784  double val4 ;
23785  int ecode4 = 0 ;
23786  octave_value_list _out;
23787  octave_value_list *_outp=&_out;
23788  octave_value _outv;
23789 
23790  if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
23791  SWIG_fail;
23792  }
23793  ecode1 = SWIG_AsVal_double(args(0), &val1);
23794  if (!SWIG_IsOK(ecode1)) {
23795  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
23796  }
23797  arg1 = static_cast< PLFLT >(val1);
23798  ecode2 = SWIG_AsVal_double(args(1), &val2);
23799  if (!SWIG_IsOK(ecode2)) {
23800  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
23801  }
23802  arg2 = static_cast< PLFLT >(val2);
23803  ecode3 = SWIG_AsVal_double(args(2), &val3);
23804  if (!SWIG_IsOK(ecode3)) {
23805  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
23806  }
23807  arg3 = static_cast< PLFLT >(val3);
23808  ecode4 = SWIG_AsVal_double(args(3), &val4);
23809  if (!SWIG_IsOK(ecode4)) {
23810  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
23811  }
23812  arg4 = static_cast< PLFLT >(val4);
23813  plvpor(arg1,arg2,arg3,arg4);
23814  _outv = octave_value();
23815  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23816  return _out;
23817 fail:
23818  return octave_value_list();
23819 }
23820 
23821 
23823  octave_value_list _out;
23824  octave_value_list *_outp=&_out;
23825  octave_value _outv;
23826 
23827  if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
23828  SWIG_fail;
23829  }
23830  plvsta();
23831  _outv = octave_value();
23832  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23833  return _out;
23834 fail:
23835  return octave_value_list();
23836 }
23837 
23838 
23840  PLFLT arg1 ;
23841  PLFLT arg2 ;
23842  PLFLT arg3 ;
23843  PLFLT arg4 ;
23844  PLFLT arg5 ;
23845  PLFLT arg6 ;
23846  PLFLT arg7 ;
23847  PLFLT arg8 ;
23848  PLFLT arg9 ;
23849  PLFLT arg10 ;
23850  PLFLT arg11 ;
23851  double val1 ;
23852  int ecode1 = 0 ;
23853  double val2 ;
23854  int ecode2 = 0 ;
23855  double val3 ;
23856  int ecode3 = 0 ;
23857  double val4 ;
23858  int ecode4 = 0 ;
23859  double val5 ;
23860  int ecode5 = 0 ;
23861  double val6 ;
23862  int ecode6 = 0 ;
23863  double val7 ;
23864  int ecode7 = 0 ;
23865  double val8 ;
23866  int ecode8 = 0 ;
23867  double val9 ;
23868  int ecode9 = 0 ;
23869  double val10 ;
23870  int ecode10 = 0 ;
23871  double val11 ;
23872  int ecode11 = 0 ;
23873  octave_value_list _out;
23874  octave_value_list *_outp=&_out;
23875  octave_value _outv;
23876 
23877  if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
23878  SWIG_fail;
23879  }
23880  ecode1 = SWIG_AsVal_double(args(0), &val1);
23881  if (!SWIG_IsOK(ecode1)) {
23882  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
23883  }
23884  arg1 = static_cast< PLFLT >(val1);
23885  ecode2 = SWIG_AsVal_double(args(1), &val2);
23886  if (!SWIG_IsOK(ecode2)) {
23887  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
23888  }
23889  arg2 = static_cast< PLFLT >(val2);
23890  ecode3 = SWIG_AsVal_double(args(2), &val3);
23891  if (!SWIG_IsOK(ecode3)) {
23892  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
23893  }
23894  arg3 = static_cast< PLFLT >(val3);
23895  ecode4 = SWIG_AsVal_double(args(3), &val4);
23896  if (!SWIG_IsOK(ecode4)) {
23897  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
23898  }
23899  arg4 = static_cast< PLFLT >(val4);
23900  ecode5 = SWIG_AsVal_double(args(4), &val5);
23901  if (!SWIG_IsOK(ecode5)) {
23902  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
23903  }
23904  arg5 = static_cast< PLFLT >(val5);
23905  ecode6 = SWIG_AsVal_double(args(5), &val6);
23906  if (!SWIG_IsOK(ecode6)) {
23907  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
23908  }
23909  arg6 = static_cast< PLFLT >(val6);
23910  ecode7 = SWIG_AsVal_double(args(6), &val7);
23911  if (!SWIG_IsOK(ecode7)) {
23912  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
23913  }
23914  arg7 = static_cast< PLFLT >(val7);
23915  ecode8 = SWIG_AsVal_double(args(7), &val8);
23916  if (!SWIG_IsOK(ecode8)) {
23917  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
23918  }
23919  arg8 = static_cast< PLFLT >(val8);
23920  ecode9 = SWIG_AsVal_double(args(8), &val9);
23921  if (!SWIG_IsOK(ecode9)) {
23922  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
23923  }
23924  arg9 = static_cast< PLFLT >(val9);
23925  ecode10 = SWIG_AsVal_double(args(9), &val10);
23926  if (!SWIG_IsOK(ecode10)) {
23927  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
23928  }
23929  arg10 = static_cast< PLFLT >(val10);
23930  ecode11 = SWIG_AsVal_double(args(10), &val11);
23931  if (!SWIG_IsOK(ecode11)) {
23932  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
23933  }
23934  arg11 = static_cast< PLFLT >(val11);
23935  plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
23936  _outv = octave_value();
23937  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23938  return _out;
23939 fail:
23940  return octave_value_list();
23941 }
23942 
23943 
23945  PLFLT arg1 ;
23946  double val1 ;
23947  int ecode1 = 0 ;
23948  octave_value_list _out;
23949  octave_value_list *_outp=&_out;
23950  octave_value _outv;
23951 
23952  if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
23953  SWIG_fail;
23954  }
23955  ecode1 = SWIG_AsVal_double(args(0), &val1);
23956  if (!SWIG_IsOK(ecode1)) {
23957  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
23958  }
23959  arg1 = static_cast< PLFLT >(val1);
23960  plwidth(arg1);
23961  _outv = octave_value();
23962  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23963  return _out;
23964 fail:
23965  return octave_value_list();
23966 }
23967 
23968 
23970  PLFLT arg1 ;
23971  PLFLT arg2 ;
23972  PLFLT arg3 ;
23973  PLFLT arg4 ;
23974  double val1 ;
23975  int ecode1 = 0 ;
23976  double val2 ;
23977  int ecode2 = 0 ;
23978  double val3 ;
23979  int ecode3 = 0 ;
23980  double val4 ;
23981  int ecode4 = 0 ;
23982  octave_value_list _out;
23983  octave_value_list *_outp=&_out;
23984  octave_value _outv;
23985 
23986  if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
23987  SWIG_fail;
23988  }
23989  ecode1 = SWIG_AsVal_double(args(0), &val1);
23990  if (!SWIG_IsOK(ecode1)) {
23991  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
23992  }
23993  arg1 = static_cast< PLFLT >(val1);
23994  ecode2 = SWIG_AsVal_double(args(1), &val2);
23995  if (!SWIG_IsOK(ecode2)) {
23996  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
23997  }
23998  arg2 = static_cast< PLFLT >(val2);
23999  ecode3 = SWIG_AsVal_double(args(2), &val3);
24000  if (!SWIG_IsOK(ecode3)) {
24001  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
24002  }
24003  arg3 = static_cast< PLFLT >(val3);
24004  ecode4 = SWIG_AsVal_double(args(3), &val4);
24005  if (!SWIG_IsOK(ecode4)) {
24006  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
24007  }
24008  arg4 = static_cast< PLFLT >(val4);
24009  plwind(arg1,arg2,arg3,arg4);
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 
24017 
24019  PLBOOL arg1 ;
24020  PLBOOL *arg2 = (PLBOOL *) 0 ;
24021  int val1 ;
24022  int ecode1 = 0 ;
24023  PLBOOL temp2 ;
24024  int res2 = SWIG_TMPOBJ ;
24025  octave_value_list _out;
24026  octave_value_list *_outp=&_out;
24027  octave_value _outv;
24028 
24029  arg2 = &temp2;
24030  if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
24031  SWIG_fail;
24032  }
24033  ecode1 = SWIG_AsVal_int(args(0), &val1);
24034  if (!SWIG_IsOK(ecode1)) {
24035  SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
24036  }
24037  arg1 = static_cast< PLBOOL >(val1);
24038  plxormod(arg1,arg2);
24039  _outv = octave_value();
24040  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24041  if (SWIG_IsTmpObj(res2)) {
24042  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
24043  } else {
24044  int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24045  _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
24046  }
24047  return _out;
24048 fail:
24049  return octave_value_list();
24050 }
24051 
24052 
24054  mapform_func arg1 = (mapform_func) 0 ;
24055  char *arg2 = (char *) 0 ;
24056  PLFLT arg3 ;
24057  PLFLT arg4 ;
24058  PLFLT arg5 ;
24059  PLFLT arg6 ;
24060  int res2 ;
24061  char *buf2 = 0 ;
24062  int alloc2 = 0 ;
24063  double val3 ;
24064  int ecode3 = 0 ;
24065  double val4 ;
24066  int ecode4 = 0 ;
24067  double val5 ;
24068  int ecode5 = 0 ;
24069  double val6 ;
24070  int ecode6 = 0 ;
24071  octave_value_list _out;
24072  octave_value_list *_outp=&_out;
24073  octave_value _outv;
24074 
24075  if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
24076  SWIG_fail;
24077  }
24078  {
24079  octave_value obj = args(0);
24080 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24081  if ( !obj.isempty() )
24082 #else
24083  if ( !obj.is_empty() )
24084 #endif
24085  {
24086  if ( obj.is_function_handle() || obj.is_inline_function() )
24087  {
24088  fcnMapForm = obj.function_value();
24089  }
24090  else if ( obj.is_string() )
24091  {
24092  nameMapForm = obj.string_value();
24093  fcnMapForm = NULL;
24094  }
24095  arg1 = mapform_octave;
24096  }
24097  else
24098  {
24099  arg1 = NULL;
24100  }
24101  }
24102  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24103  if (!SWIG_IsOK(res2)) {
24104  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
24105  }
24106  arg2 = reinterpret_cast< char * >(buf2);
24107  ecode3 = SWIG_AsVal_double(args(2), &val3);
24108  if (!SWIG_IsOK(ecode3)) {
24109  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
24110  }
24111  arg3 = static_cast< PLFLT >(val3);
24112  ecode4 = SWIG_AsVal_double(args(3), &val4);
24113  if (!SWIG_IsOK(ecode4)) {
24114  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
24115  }
24116  arg4 = static_cast< PLFLT >(val4);
24117  ecode5 = SWIG_AsVal_double(args(4), &val5);
24118  if (!SWIG_IsOK(ecode5)) {
24119  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
24120  }
24121  arg5 = static_cast< PLFLT >(val5);
24122  ecode6 = SWIG_AsVal_double(args(5), &val6);
24123  if (!SWIG_IsOK(ecode6)) {
24124  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
24125  }
24126  arg6 = static_cast< PLFLT >(val6);
24127  plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
24128  _outv = octave_value();
24129  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24130  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24131  return _out;
24132 fail:
24133  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24134  return octave_value_list();
24135 }
24136 
24137 
24139  mapform_func arg1 = (mapform_func) 0 ;
24140  char *arg2 = (char *) 0 ;
24141  PLFLT arg3 ;
24142  PLFLT arg4 ;
24143  PLFLT arg5 ;
24144  PLFLT arg6 ;
24145  PLINT *arg7 = (PLINT *) 0 ;
24146  PLINT arg8 ;
24147  int res2 ;
24148  char *buf2 = 0 ;
24149  int alloc2 = 0 ;
24150  double val3 ;
24151  int ecode3 = 0 ;
24152  double val4 ;
24153  int ecode4 = 0 ;
24154  double val5 ;
24155  int ecode5 = 0 ;
24156  double val6 ;
24157  int ecode6 = 0 ;
24158  Matrix temp7 ;
24159  octave_value_list _out;
24160  octave_value_list *_outp=&_out;
24161  octave_value _outv;
24162 
24163  if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
24164  SWIG_fail;
24165  }
24166  {
24167  octave_value obj = args(0);
24168 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24169  if ( !obj.isempty() )
24170 #else
24171  if ( !obj.is_empty() )
24172 #endif
24173  {
24174  if ( obj.is_function_handle() || obj.is_inline_function() )
24175  {
24176  fcnMapForm = obj.function_value();
24177  }
24178  else if ( obj.is_string() )
24179  {
24180  nameMapForm = obj.string_value();
24181  fcnMapForm = NULL;
24182  }
24183  arg1 = mapform_octave;
24184  }
24185  else
24186  {
24187  arg1 = NULL;
24188  }
24189  }
24190  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24191  if (!SWIG_IsOK(res2)) {
24192  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
24193  }
24194  arg2 = reinterpret_cast< char * >(buf2);
24195  ecode3 = SWIG_AsVal_double(args(2), &val3);
24196  if (!SWIG_IsOK(ecode3)) {
24197  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
24198  }
24199  arg3 = static_cast< PLFLT >(val3);
24200  ecode4 = SWIG_AsVal_double(args(3), &val4);
24201  if (!SWIG_IsOK(ecode4)) {
24202  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
24203  }
24204  arg4 = static_cast< PLFLT >(val4);
24205  ecode5 = SWIG_AsVal_double(args(4), &val5);
24206  if (!SWIG_IsOK(ecode5)) {
24207  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
24208  }
24209  arg5 = static_cast< PLFLT >(val5);
24210  ecode6 = SWIG_AsVal_double(args(5), &val6);
24211  if (!SWIG_IsOK(ecode6)) {
24212  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
24213  }
24214  arg6 = static_cast< PLFLT >(val6);
24215  {
24216  if ( _n_dims( args(6) ) > 1 )
24217  {
24218  error( "argument must be a scalar or vector" ); SWIG_fail;
24219  }
24220 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24221  if ( !args(6).isempty() )
24222 #else
24223  if ( !args(6).is_empty() )
24224 #endif
24225  {
24226  arg8 = (PLINT) ( _dim( args(6), 0 ) );
24227  temp7 = args(6).matrix_value();
24228  arg7 = new PLINT[arg8];
24229  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
24230  }
24231  else
24232  {
24233  arg7 = NULL;
24234  arg8 = 0;
24235  }
24236  }
24237  plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
24238  _outv = octave_value();
24239  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24240  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24241  {
24242  delete [] arg7;
24243  }
24244  return _out;
24245 fail:
24246  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24247  {
24248  delete [] arg7;
24249  }
24250  return octave_value_list();
24251 }
24252 
24253 
24255  mapform_func arg1 = (mapform_func) 0 ;
24256  char *arg2 = (char *) 0 ;
24257  char *arg3 = (char *) 0 ;
24258  PLFLT arg4 ;
24259  PLFLT arg5 ;
24260  PLFLT arg6 ;
24261  PLFLT arg7 ;
24262  PLINT *arg8 = (PLINT *) 0 ;
24263  PLINT arg9 ;
24264  int res2 ;
24265  char *buf2 = 0 ;
24266  int alloc2 = 0 ;
24267  int res3 ;
24268  char *buf3 = 0 ;
24269  int alloc3 = 0 ;
24270  double val4 ;
24271  int ecode4 = 0 ;
24272  double val5 ;
24273  int ecode5 = 0 ;
24274  double val6 ;
24275  int ecode6 = 0 ;
24276  double val7 ;
24277  int ecode7 = 0 ;
24278  Matrix temp8 ;
24279  octave_value_list _out;
24280  octave_value_list *_outp=&_out;
24281  octave_value _outv;
24282 
24283  if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
24284  SWIG_fail;
24285  }
24286  {
24287  octave_value obj = args(0);
24288 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24289  if ( !obj.isempty() )
24290 #else
24291  if ( !obj.is_empty() )
24292 #endif
24293  {
24294  if ( obj.is_function_handle() || obj.is_inline_function() )
24295  {
24296  fcnMapForm = obj.function_value();
24297  }
24298  else if ( obj.is_string() )
24299  {
24300  nameMapForm = obj.string_value();
24301  fcnMapForm = NULL;
24302  }
24303  arg1 = mapform_octave;
24304  }
24305  else
24306  {
24307  arg1 = NULL;
24308  }
24309  }
24310  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24311  if (!SWIG_IsOK(res2)) {
24312  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
24313  }
24314  arg2 = reinterpret_cast< char * >(buf2);
24315  res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
24316  if (!SWIG_IsOK(res3)) {
24317  SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
24318  }
24319  arg3 = reinterpret_cast< char * >(buf3);
24320  ecode4 = SWIG_AsVal_double(args(3), &val4);
24321  if (!SWIG_IsOK(ecode4)) {
24322  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
24323  }
24324  arg4 = static_cast< PLFLT >(val4);
24325  ecode5 = SWIG_AsVal_double(args(4), &val5);
24326  if (!SWIG_IsOK(ecode5)) {
24327  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
24328  }
24329  arg5 = static_cast< PLFLT >(val5);
24330  ecode6 = SWIG_AsVal_double(args(5), &val6);
24331  if (!SWIG_IsOK(ecode6)) {
24332  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
24333  }
24334  arg6 = static_cast< PLFLT >(val6);
24335  ecode7 = SWIG_AsVal_double(args(6), &val7);
24336  if (!SWIG_IsOK(ecode7)) {
24337  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
24338  }
24339  arg7 = static_cast< PLFLT >(val7);
24340  {
24341  if ( _n_dims( args(7) ) > 1 )
24342  {
24343  error( "argument must be a scalar or vector" ); SWIG_fail;
24344  }
24345 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24346  if ( !args(7).isempty() )
24347 #else
24348  if ( !args(7).is_empty() )
24349 #endif
24350  {
24351  arg9 = (PLINT) ( _dim( args(7), 0 ) );
24352  temp8 = args(7).matrix_value();
24353  arg8 = new PLINT[arg9];
24354  _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
24355  }
24356  else
24357  {
24358  arg8 = NULL;
24359  arg9 = 0;
24360  }
24361  }
24362  plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
24363  _outv = octave_value();
24364  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24365  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24366  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
24367  {
24368  delete [] arg8;
24369  }
24370  return _out;
24371 fail:
24372  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24373  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
24374  {
24375  delete [] arg8;
24376  }
24377  return octave_value_list();
24378 }
24379 
24380 
24382  mapform_func arg1 = (mapform_func) 0 ;
24383  char *arg2 = (char *) 0 ;
24384  PLFLT arg3 ;
24385  PLFLT arg4 ;
24386  PLFLT arg5 ;
24387  char *arg6 = (char *) 0 ;
24388  PLFLT arg7 ;
24389  PLFLT arg8 ;
24390  PLFLT arg9 ;
24391  PLFLT arg10 ;
24392  PLINT arg11 ;
24393  int res2 ;
24394  char *buf2 = 0 ;
24395  int alloc2 = 0 ;
24396  double val3 ;
24397  int ecode3 = 0 ;
24398  double val4 ;
24399  int ecode4 = 0 ;
24400  double val5 ;
24401  int ecode5 = 0 ;
24402  int res6 ;
24403  char *buf6 = 0 ;
24404  int alloc6 = 0 ;
24405  double val7 ;
24406  int ecode7 = 0 ;
24407  double val8 ;
24408  int ecode8 = 0 ;
24409  double val9 ;
24410  int ecode9 = 0 ;
24411  double val10 ;
24412  int ecode10 = 0 ;
24413  int val11 ;
24414  int ecode11 = 0 ;
24415  octave_value_list _out;
24416  octave_value_list *_outp=&_out;
24417  octave_value _outv;
24418 
24419  if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
24420  SWIG_fail;
24421  }
24422  {
24423  octave_value obj = args(0);
24424 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24425  if ( !obj.isempty() )
24426 #else
24427  if ( !obj.is_empty() )
24428 #endif
24429  {
24430  if ( obj.is_function_handle() || obj.is_inline_function() )
24431  {
24432  fcnMapForm = obj.function_value();
24433  }
24434  else if ( obj.is_string() )
24435  {
24436  nameMapForm = obj.string_value();
24437  fcnMapForm = NULL;
24438  }
24439  arg1 = mapform_octave;
24440  }
24441  else
24442  {
24443  arg1 = NULL;
24444  }
24445  }
24446  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24447  if (!SWIG_IsOK(res2)) {
24448  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
24449  }
24450  arg2 = reinterpret_cast< char * >(buf2);
24451  ecode3 = SWIG_AsVal_double(args(2), &val3);
24452  if (!SWIG_IsOK(ecode3)) {
24453  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
24454  }
24455  arg3 = static_cast< PLFLT >(val3);
24456  ecode4 = SWIG_AsVal_double(args(3), &val4);
24457  if (!SWIG_IsOK(ecode4)) {
24458  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
24459  }
24460  arg4 = static_cast< PLFLT >(val4);
24461  ecode5 = SWIG_AsVal_double(args(4), &val5);
24462  if (!SWIG_IsOK(ecode5)) {
24463  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
24464  }
24465  arg5 = static_cast< PLFLT >(val5);
24466  res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
24467  if (!SWIG_IsOK(res6)) {
24468  SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
24469  }
24470  arg6 = reinterpret_cast< char * >(buf6);
24471  ecode7 = SWIG_AsVal_double(args(6), &val7);
24472  if (!SWIG_IsOK(ecode7)) {
24473  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
24474  }
24475  arg7 = static_cast< PLFLT >(val7);
24476  ecode8 = SWIG_AsVal_double(args(7), &val8);
24477  if (!SWIG_IsOK(ecode8)) {
24478  SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
24479  }
24480  arg8 = static_cast< PLFLT >(val8);
24481  ecode9 = SWIG_AsVal_double(args(8), &val9);
24482  if (!SWIG_IsOK(ecode9)) {
24483  SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
24484  }
24485  arg9 = static_cast< PLFLT >(val9);
24486  ecode10 = SWIG_AsVal_double(args(9), &val10);
24487  if (!SWIG_IsOK(ecode10)) {
24488  SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
24489  }
24490  arg10 = static_cast< PLFLT >(val10);
24491  ecode11 = SWIG_AsVal_int(args(10), &val11);
24492  if (!SWIG_IsOK(ecode11)) {
24493  SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
24494  }
24495  arg11 = static_cast< PLINT >(val11);
24496  plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
24497  _outv = octave_value();
24498  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24499  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24500  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
24501  return _out;
24502 fail:
24503  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24504  if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
24505  return octave_value_list();
24506 }
24507 
24508 
24510  mapform_func arg1 = (mapform_func) 0 ;
24511  char *arg2 = (char *) 0 ;
24512  PLFLT arg3 ;
24513  PLFLT arg4 ;
24514  PLFLT arg5 ;
24515  PLFLT arg6 ;
24516  PLINT *arg7 = (PLINT *) 0 ;
24517  PLINT arg8 ;
24518  int res2 ;
24519  char *buf2 = 0 ;
24520  int alloc2 = 0 ;
24521  double val3 ;
24522  int ecode3 = 0 ;
24523  double val4 ;
24524  int ecode4 = 0 ;
24525  double val5 ;
24526  int ecode5 = 0 ;
24527  double val6 ;
24528  int ecode6 = 0 ;
24529  Matrix temp7 ;
24530  octave_value_list _out;
24531  octave_value_list *_outp=&_out;
24532  octave_value _outv;
24533 
24534  if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
24535  SWIG_fail;
24536  }
24537  {
24538  octave_value obj = args(0);
24539 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24540  if ( !obj.isempty() )
24541 #else
24542  if ( !obj.is_empty() )
24543 #endif
24544  {
24545  if ( obj.is_function_handle() || obj.is_inline_function() )
24546  {
24547  fcnMapForm = obj.function_value();
24548  }
24549  else if ( obj.is_string() )
24550  {
24551  nameMapForm = obj.string_value();
24552  fcnMapForm = NULL;
24553  }
24554  arg1 = mapform_octave;
24555  }
24556  else
24557  {
24558  arg1 = NULL;
24559  }
24560  }
24561  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24562  if (!SWIG_IsOK(res2)) {
24563  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
24564  }
24565  arg2 = reinterpret_cast< char * >(buf2);
24566  ecode3 = SWIG_AsVal_double(args(2), &val3);
24567  if (!SWIG_IsOK(ecode3)) {
24568  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
24569  }
24570  arg3 = static_cast< PLFLT >(val3);
24571  ecode4 = SWIG_AsVal_double(args(3), &val4);
24572  if (!SWIG_IsOK(ecode4)) {
24573  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
24574  }
24575  arg4 = static_cast< PLFLT >(val4);
24576  ecode5 = SWIG_AsVal_double(args(4), &val5);
24577  if (!SWIG_IsOK(ecode5)) {
24578  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
24579  }
24580  arg5 = static_cast< PLFLT >(val5);
24581  ecode6 = SWIG_AsVal_double(args(5), &val6);
24582  if (!SWIG_IsOK(ecode6)) {
24583  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
24584  }
24585  arg6 = static_cast< PLFLT >(val6);
24586  {
24587  if ( _n_dims( args(6) ) > 1 )
24588  {
24589  error( "argument must be a scalar or vector" ); SWIG_fail;
24590  }
24591 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24592  if ( !args(6).isempty() )
24593 #else
24594  if ( !args(6).is_empty() )
24595 #endif
24596  {
24597  arg8 = (PLINT) ( _dim( args(6), 0 ) );
24598  temp7 = args(6).matrix_value();
24599  arg7 = new PLINT[arg8];
24600  _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
24601  }
24602  else
24603  {
24604  arg7 = NULL;
24605  arg8 = 0;
24606  }
24607  }
24608  plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
24609  _outv = octave_value();
24610  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24611  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24612  {
24613  delete [] arg7;
24614  }
24615  return _out;
24616 fail:
24617  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24618  {
24619  delete [] arg7;
24620  }
24621  return octave_value_list();
24622 }
24623 
24624 
24626  mapform_func arg1 = (mapform_func) 0 ;
24627  PLFLT arg2 ;
24628  PLFLT arg3 ;
24629  PLFLT arg4 ;
24630  PLFLT arg5 ;
24631  PLFLT arg6 ;
24632  PLFLT arg7 ;
24633  double val2 ;
24634  int ecode2 = 0 ;
24635  double val3 ;
24636  int ecode3 = 0 ;
24637  double val4 ;
24638  int ecode4 = 0 ;
24639  double val5 ;
24640  int ecode5 = 0 ;
24641  double val6 ;
24642  int ecode6 = 0 ;
24643  double val7 ;
24644  int ecode7 = 0 ;
24645  octave_value_list _out;
24646  octave_value_list *_outp=&_out;
24647  octave_value _outv;
24648 
24649  if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
24650  SWIG_fail;
24651  }
24652  {
24653  octave_value obj = args(0);
24654 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24655  if ( !obj.isempty() )
24656 #else
24657  if ( !obj.is_empty() )
24658 #endif
24659  {
24660  if ( obj.is_function_handle() || obj.is_inline_function() )
24661  {
24662  fcnMapForm = obj.function_value();
24663  }
24664  else if ( obj.is_string() )
24665  {
24666  nameMapForm = obj.string_value();
24667  fcnMapForm = NULL;
24668  }
24669  arg1 = mapform_octave;
24670  }
24671  else
24672  {
24673  arg1 = NULL;
24674  }
24675  }
24676  ecode2 = SWIG_AsVal_double(args(1), &val2);
24677  if (!SWIG_IsOK(ecode2)) {
24678  SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
24679  }
24680  arg2 = static_cast< PLFLT >(val2);
24681  ecode3 = SWIG_AsVal_double(args(2), &val3);
24682  if (!SWIG_IsOK(ecode3)) {
24683  SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
24684  }
24685  arg3 = static_cast< PLFLT >(val3);
24686  ecode4 = SWIG_AsVal_double(args(3), &val4);
24687  if (!SWIG_IsOK(ecode4)) {
24688  SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
24689  }
24690  arg4 = static_cast< PLFLT >(val4);
24691  ecode5 = SWIG_AsVal_double(args(4), &val5);
24692  if (!SWIG_IsOK(ecode5)) {
24693  SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
24694  }
24695  arg5 = static_cast< PLFLT >(val5);
24696  ecode6 = SWIG_AsVal_double(args(5), &val6);
24697  if (!SWIG_IsOK(ecode6)) {
24698  SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
24699  }
24700  arg6 = static_cast< PLFLT >(val6);
24701  ecode7 = SWIG_AsVal_double(args(6), &val7);
24702  if (!SWIG_IsOK(ecode7)) {
24703  SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
24704  }
24705  arg7 = static_cast< PLFLT >(val7);
24706  plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24707  _outv = octave_value();
24708  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24709  return _out;
24710 fail:
24711  return octave_value_list();
24712 }
24713 
24714 
24716  octave_value_list _out;
24717  octave_value_list *_outp=&_out;
24718  octave_value _outv;
24719 
24720  if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
24721  SWIG_fail;
24722  }
24723  plClearOpts();
24724  _outv = octave_value();
24725  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24726  return _out;
24727 fail:
24728  return octave_value_list();
24729 }
24730 
24731 
24733  octave_value_list _out;
24734  octave_value_list *_outp=&_out;
24735  octave_value _outv;
24736 
24737  if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
24738  SWIG_fail;
24739  }
24740  plResetOpts();
24741  _outv = octave_value();
24742  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24743  return _out;
24744 fail:
24745  return octave_value_list();
24746 }
24747 
24748 
24750  char *arg1 = (char *) 0 ;
24751  char *arg2 = (char *) 0 ;
24752  int res1 ;
24753  char *buf1 = 0 ;
24754  int alloc1 = 0 ;
24755  int res2 ;
24756  char *buf2 = 0 ;
24757  int alloc2 = 0 ;
24758  octave_value_list _out;
24759  octave_value_list *_outp=&_out;
24760  octave_value _outv;
24761 
24762  if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
24763  SWIG_fail;
24764  }
24765  res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24766  if (!SWIG_IsOK(res1)) {
24767  SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
24768  }
24769  arg1 = reinterpret_cast< char * >(buf1);
24770  res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24771  if (!SWIG_IsOK(res2)) {
24772  SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
24773  }
24774  arg2 = reinterpret_cast< char * >(buf2);
24775  plSetUsage((char const *)arg1,(char const *)arg2);
24776  _outv = octave_value();
24777  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24778  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24779  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24780  return _out;
24781 fail:
24782  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24783  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24784  return octave_value_list();
24785 }
24786 
24787 
24789  octave_value_list _out;
24790  octave_value_list *_outp=&_out;
24791  octave_value _outv;
24792 
24793  if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
24794  SWIG_fail;
24795  }
24796  plOptUsage();
24797  _outv = octave_value();
24798  if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24799  return _out;
24800 fail:
24801  return octave_value_list();
24802 }
24803 
24804 
24805 
24806 static const struct swig_octave_member swig_globals[] = {
24807 {"testppchar",_wrap_testppchar,0,0,2,0},
24808 {"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
24809 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
24810 {"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
24811 {"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
24812 {"plcont0",_wrap_plcont0,0,0,2,0},
24813 {"plcont1",_wrap_plcont1,0,0,2,0},
24814 {"plcont2",_wrap_plcont2,0,0,2,0},
24815 {"plcont2p",_wrap_plcont2p,0,0,2,0},
24816 {"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
24817 {"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
24818 {"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
24819 {"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
24820 {"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
24821 {"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
24822 {"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
24823 {"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
24824 {"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
24825 {"plshade1",_wrap_plshade1,0,0,2,0},
24826 {"plshade2",_wrap_plshade2,0,0,2,0},
24827 {"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
24828 {"plshadesx",_wrap_plshadesx,0,0,2,0},
24829 {"plshades1",_wrap_plshades1,0,0,2,0},
24830 {"plshades2",_wrap_plshades2,0,0,2,0},
24831 {"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
24832 {"plvect1",_wrap_plvect1,0,0,2,0},
24833 {"plvect2",_wrap_plvect2,0,0,2,0},
24834 {"pplimage",_wrap_pplimage,0,0,2,0},
24835 {"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
24836 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
24837 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
24838 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
24839 {"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
24840 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
24841 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
24842 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
24843 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
24844 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
24845 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
24846 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
24847 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
24848 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
24849 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
24850 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
24851 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
24852 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
24853 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
24854 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
24855 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
24856 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
24857 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
24858 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
24859 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
24860 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
24861 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
24862 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
24863 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
24864 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
24865 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
24867 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
24868 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
24869 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
24870 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
24871 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
24872 {"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
24873 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
24874 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
24875 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
24876 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
24877 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
24878 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
24879 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
24880 {"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
24881 {"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
24882 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
24883 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
24884 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
24885 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
24886 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
24887 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
24888 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
24889 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
24890 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
24891 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
24892 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
24893 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
24894 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
24895 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
24896 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
24897 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
24898 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
24899 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
24900 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
24901 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
24902 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
24903 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
24904 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
24905 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
24906 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
24907 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
24908 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
24909 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
24910 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
24911 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
24912 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
24913 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
24914 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
24915 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
24916 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
24917 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
24918 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
24919 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
24920 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
24921 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
24922 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
24923 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
24924 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
24925 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
24926 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
24927 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
24928 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
24929 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
24930 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
24931 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
24932 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
24933 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
24934 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
24935 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
24936 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
24937 {"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
24938 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
24939 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
24940 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
24941 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
24942 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
24943 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
24944 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
24945 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
24946 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
24947 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
24948 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
24949 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
24950 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
24951 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
24952 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
24953 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
24954 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
24955 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
24956 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
24957 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
24958 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
24959 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
24960 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
24961 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
24962 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
24963 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
24964 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
24965 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
24966 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
24967 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
24968 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
24969 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
24970 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
24971 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
24972 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
24973 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
24974 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
24975 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
24976 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
24977 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
24978 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
24979 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
24980 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
24981 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
24982 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
24983 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
24984 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
24985 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
24986 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
24987 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
24988 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
24989 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
24990 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
24991 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
24992 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
24993 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
24994 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
24995 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
24996 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
24997 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
24998 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
24999 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
25000 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
25001 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
25002 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
25003 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
25004 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
25005 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
25006 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
25007 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
25008 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
25009 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
25010 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
25011 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
25012 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
25013 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
25014 {"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
25015 {"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
25016 {"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
25017 {"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
25018 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
25019 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
25020 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
25021 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
25022 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
25023 {0,0,0,0,0,0}
25024 };
25025 
25026 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
25027 
25028 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
25029 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
25030 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
25031 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};
25032 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};
25033 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};
25034 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
25035 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
25036 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
25037 
25040  &_swigt__p_char,
25045  &_swigt__p_int,
25048 };
25049 
25050 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
25051 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
25052 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
25056 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
25057 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
25058 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
25059 
25067  _swigc__p_int,
25070 };
25071 
25072 
25073 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
25074 
25075 /* -----------------------------------------------------------------------------
25076  * Type initialization:
25077  * This problem is tough by the requirement that no dynamic
25078  * memory is used. Also, since swig_type_info structures store pointers to
25079  * swig_cast_info structures and swig_cast_info structures store pointers back
25080  * to swig_type_info structures, we need some lookup code at initialization.
25081  * The idea is that swig generates all the structures that are needed.
25082  * The runtime then collects these partially filled structures.
25083  * The SWIG_InitializeModule function takes these initial arrays out of
25084  * swig_module, and does all the lookup, filling in the swig_module.types
25085  * array with the correct data and linking the correct swig_cast_info
25086  * structures together.
25087  *
25088  * The generated swig_type_info structures are assigned statically to an initial
25089  * array. We just loop through that array, and handle each type individually.
25090  * First we lookup if this type has been already loaded, and if so, use the
25091  * loaded structure instead of the generated one. Then we have to fill in the
25092  * cast linked list. The cast data is initially stored in something like a
25093  * two-dimensional array. Each row corresponds to a type (there are the same
25094  * number of rows as there are in the swig_type_initial array). Each entry in
25095  * a column is one of the swig_cast_info structures for that type.
25096  * The cast_initial array is actually an array of arrays, because each row has
25097  * a variable number of columns. So to actually build the cast linked list,
25098  * we find the array of casts associated with the type, and loop through it
25099  * adding the casts to the list. The one last trick we need to do is making
25100  * sure the type pointer in the swig_cast_info struct is correct.
25101  *
25102  * First off, we lookup the cast->type name to see if it is already loaded.
25103  * There are three cases to handle:
25104  * 1) If the cast->type has already been loaded AND the type we are adding
25105  * casting info to has not been loaded (it is in this module), THEN we
25106  * replace the cast->type pointer with the type pointer that has already
25107  * been loaded.
25108  * 2) If BOTH types (the one we are adding casting info to, and the
25109  * cast->type) are loaded, THEN the cast info has already been loaded by
25110  * the previous module so we just ignore it.
25111  * 3) Finally, if cast->type has not already been loaded, then we add that
25112  * swig_cast_info to the linked list (because the cast->type) pointer will
25113  * be correct.
25114  * ----------------------------------------------------------------------------- */
25115 
25116 #ifdef __cplusplus
25117 extern "C" {
25118 #if 0
25119 } /* c-mode */
25120 #endif
25121 #endif
25122 
25123 #if 0
25124 #define SWIGRUNTIME_DEBUG
25125 #endif
25126 
25127 
25128 SWIGRUNTIME void
25129 SWIG_InitializeModule(void *clientdata) {
25130  size_t i;
25131  swig_module_info *module_head, *iter;
25132  int init;
25133 
25134  /* check to see if the circular list has been setup, if not, set it up */
25135  if (swig_module.next==0) {
25136  /* Initialize the swig_module */
25140  init = 1;
25141  } else {
25142  init = 0;
25143  }
25144 
25145  /* Try and load any already created modules */
25146  module_head = SWIG_GetModule(clientdata);
25147  if (!module_head) {
25148  /* This is the first module loaded for this interpreter */
25149  /* so set the swig module into the interpreter */
25150  SWIG_SetModule(clientdata, &swig_module);
25151  } else {
25152  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
25153  iter=module_head;
25154  do {
25155  if (iter==&swig_module) {
25156  /* Our module is already in the list, so there's nothing more to do. */
25157  return;
25158  }
25159  iter=iter->next;
25160  } while (iter!= module_head);
25161 
25162  /* otherwise we must add our module into the list */
25163  swig_module.next = module_head->next;
25164  module_head->next = &swig_module;
25165  }
25166 
25167  /* When multiple interpreters are used, a module could have already been initialized in
25168  a different interpreter, but not yet have a pointer in this interpreter.
25169  In this case, we do not want to continue adding types... everything should be
25170  set up already */
25171  if (init == 0) return;
25172 
25173  /* Now work on filling in swig_module.types */
25174 #ifdef SWIGRUNTIME_DEBUG
25175  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
25176 #endif
25177  for (i = 0; i < swig_module.size; ++i) {
25178  swig_type_info *type = 0;
25179  swig_type_info *ret;
25181 
25182 #ifdef SWIGRUNTIME_DEBUG
25183  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
25184 #endif
25185 
25186  /* if there is another module already loaded */
25187  if (swig_module.next != &swig_module) {
25189  }
25190  if (type) {
25191  /* Overwrite clientdata field */
25192 #ifdef SWIGRUNTIME_DEBUG
25193  printf("SWIG_InitializeModule: found type %s\n", type->name);
25194 #endif
25197 #ifdef SWIGRUNTIME_DEBUG
25198  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
25199 #endif
25200  }
25201  } else {
25202  type = swig_module.type_initial[i];
25203  }
25204 
25205  /* Insert casting types */
25207  while (cast->type) {
25208 
25209  /* Don't need to add information already in the list */
25210  ret = 0;
25211 #ifdef SWIGRUNTIME_DEBUG
25212  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
25213 #endif
25214  if (swig_module.next != &swig_module) {
25216 #ifdef SWIGRUNTIME_DEBUG
25217  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
25218 #endif
25219  }
25220  if (ret) {
25221  if (type == swig_module.type_initial[i]) {
25222 #ifdef SWIGRUNTIME_DEBUG
25223  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
25224 #endif
25225  cast->type = ret;
25226  ret = 0;
25227  } else {
25228  /* Check for casting already in the list */
25229  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
25230 #ifdef SWIGRUNTIME_DEBUG
25231  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
25232 #endif
25233  if (!ocast) ret = 0;
25234  }
25235  }
25236 
25237  if (!ret) {
25238 #ifdef SWIGRUNTIME_DEBUG
25239  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
25240 #endif
25241  if (type->cast) {
25242  type->cast->prev = cast;
25243  cast->next = type->cast;
25244  }
25245  type->cast = cast;
25246  }
25247  cast++;
25248  }
25249  /* Set entry in modules->types array equal to the type */
25250  swig_module.types[i] = type;
25251  }
25252  swig_module.types[i] = 0;
25253 
25254 #ifdef SWIGRUNTIME_DEBUG
25255  printf("**** SWIG_InitializeModule: Cast List ******\n");
25256  for (i = 0; i < swig_module.size; ++i) {
25257  int j = 0;
25259  printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
25260  while (cast->type) {
25261  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
25262  cast++;
25263  ++j;
25264  }
25265  printf("---- Total casts: %d\n",j);
25266  }
25267  printf("**** SWIG_InitializeModule: Cast List ******\n");
25268 #endif
25269 }
25270 
25271 /* This function will propagate the clientdata field of type to
25272 * any new swig_type_info structures that have been added into the list
25273 * of equivalent types. It is like calling
25274 * SWIG_TypeClientData(type, clientdata) a second time.
25275 */
25276 SWIGRUNTIME void
25278  size_t i;
25279  swig_cast_info *equiv;
25280  static int init_run = 0;
25281 
25282  if (init_run) return;
25283  init_run = 1;
25284 
25285  for (i = 0; i < swig_module.size; i++) {
25286  if (swig_module.types[i]->clientdata) {
25287  equiv = swig_module.types[i]->cast;
25288  while (equiv) {
25289  if (!equiv->converter) {
25290  if (equiv->type && !equiv->type->clientdata)
25292  }
25293  equiv = equiv->next;
25294  }
25295  }
25296  }
25297 }
25298 
25299 #ifdef __cplusplus
25300 #if 0
25301 { /* c-mode */
25302 #endif
25303 }
25304 #endif
25305 
25306 
25307 
25308 static bool SWIG_init_user(octave_swig_type* module_ns);
25309 
25311  bool retn = false;
25312  {
25313 #if SWIG_OCTAVE_PREREQ(4,2,0)
25314  octave::unwind_protect frame;
25315  frame.protect_var(discard_error_messages); discard_error_messages = true;
25316  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25317 #elif SWIG_OCTAVE_PREREQ(3,3,50)
25318  unwind_protect frame;
25319  frame.protect_var(error_state); error_state = 0;
25320  frame.protect_var(warning_state); warning_state = 0;
25321  frame.protect_var(discard_error_messages); discard_error_messages = true;
25322  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25323 #else
25324  unwind_protect::begin_frame("SWIG_Octave_LoadModule");
25325  unwind_protect_int(error_state); error_state = 0;
25326  unwind_protect_int(warning_state); warning_state = 0;
25327  unwind_protect_bool(discard_error_messages); discard_error_messages = true;
25328  unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
25329 #endif
25330 #if SWIG_OCTAVE_PREREQ(4,2,0)
25331  try {
25332 #if SWIG_OCTAVE_PREREQ(4,4,0)
25333  octave::feval(name, octave_value_list(), 0);
25334 #else
25335  feval(name, octave_value_list(), 0);
25336 #endif
25337  retn = true;
25338  } catch (octave::execution_exception&) { }
25339 #else
25340  feval(name, octave_value_list(), 0);
25341  retn = (error_state == 0);
25342 #endif
25343 #if !SWIG_OCTAVE_PREREQ(3,3,50)
25344  unwind_protect::run_frame("SWIG_Octave_LoadModule");
25345 #endif
25346  }
25347  if (!retn) {
25348  error(SWIG_name_d ": could not load module `%s'", name.c_str());
25349  }
25350  return retn;
25351 }
25352 
25353 SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
25354  bool retn = false;
25355  {
25356 #if SWIG_OCTAVE_PREREQ(4,2,0)
25357  octave::unwind_protect frame;
25358  frame.protect_var(discard_error_messages); discard_error_messages = true;
25359  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25360 #elif SWIG_OCTAVE_PREREQ(3,3,50)
25361  unwind_protect frame;
25362  frame.protect_var(error_state); error_state = 0;
25363  frame.protect_var(warning_state); warning_state = 0;
25364  frame.protect_var(discard_error_messages); discard_error_messages = true;
25365  frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25366 #else
25367  unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
25368  unwind_protect_int(error_state); error_state = 0;
25369  unwind_protect_int(warning_state); warning_state = 0;
25370  unwind_protect_bool(discard_error_messages); discard_error_messages = true;
25371  unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
25372 #endif
25373  octave_value_list args;
25374  args.append(name);
25375  args.append(octloadfcn->fcn_file_name());
25376 #if SWIG_OCTAVE_PREREQ(4,2,0)
25377  try {
25378 #if SWIG_OCTAVE_PREREQ(4,4,0)
25379  octave::feval("autoload", args, 0);
25380 #else
25381  feval("autoload", args, 0);
25382 #endif
25383  retn = true;
25384  } catch (octave::execution_exception&) { }
25385 #else
25386  feval("autoload", args, 0);
25387  retn = (error_state == 0);
25388 #endif
25389 #if !SWIG_OCTAVE_PREREQ(3,3,50)
25390  unwind_protect::run_frame("SWIG_Octave_InstallFunction");
25391 #endif
25392  }
25393  if (!retn) {
25394  error(SWIG_name_d ": could not load function `%s'", name.c_str());
25395  }
25396  return retn;
25397 }
25398 
25399 static const char *const subclass_usage = "-*- texinfo -*- \n\
25400 @deftypefn {Loadable Function} {} subclass()\n\
25401 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
25402 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
25403 \n\
25404 See the SWIG manual for usage examples.\n\
25405 @end deftypefn";
25406 
25407 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
25409  for (int j = 0; j < args.length(); ++j) {
25410  if (args(j).type_id() == octave_swig_ref::static_type_id()) {
25411  octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
25412  octave_swig_type *ost = osr->get_ptr();
25413  if (!ost->is_owned()) {
25414  error("subclass: cannot subclass object not constructed on octave side");
25415  return octave_value_list();
25416  }
25417  top->merge(*ost);
25418  } else if (args(j).is_function_handle()) {
25419  top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
25420  } else if (args(j).is_string()) {
25421  if (j + 1 >= args.length()) {
25422  error("subclass: member assignments must be of string,value form");
25423  return octave_value_list();
25424  }
25425  top->assign(args(j).string_value(), args(j + 1));
25426  ++j;
25427  } else {
25428  error("subclass: invalid arguments to subclass()");
25429  return octave_value_list();
25430  }
25431  }
25432  return octave_value(Swig::swig_value_ref(top));
25433 }
25434 
25435 static const char *const swig_type_usage = "-*- texinfo -*- \n\
25436 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
25437 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
25438 @end deftypefn";
25439 
25440 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
25441  if (args.length() != 1) {
25442  error("swig_type: must be called with only a single object");
25443  return octave_value_list();
25444  }
25445  octave_swig_type *ost = Swig::swig_value_deref(args(0));
25446  if (!ost) {
25447  error("swig_type: object is not a swig_ref");
25448  return octave_value_list();
25449  }
25450  return octave_value(ost->swig_type_name());
25451 }
25452 
25453 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
25454 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
25455 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
25456 otherwise return `<unknown>'.\n\
25457 @end deftypefn";
25458 
25459 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
25460  if (args.length() != 1 || !args(0).is_string()) {
25461  error("swig_typequery: must be called with single string argument");
25462  return octave_value_list();
25463  }
25465  swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
25466  if (!type)
25467  return octave_value("<unknown>");
25468  return octave_value(type->name);
25469 }
25470 
25471 static const char *const swig_this_usage = "-*- texinfo -*- \n\
25472 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
25473 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
25474 @end deftypefn";
25475 
25477  if (args.length() != 1) {
25478  error("swig_this: must be called with only a single object");
25479  return octave_value_list();
25480  }
25481  if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
25482  return octave_value(octave_uint64(0));
25483  octave_swig_type *ost = Swig::swig_value_deref(args(0));
25484  if (!ost) {
25485  error("swig_this: object is not a swig_ref");
25486  return octave_value_list();
25487  }
25488  return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
25489 }
25490 
25491 static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
25492 @deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
25493 Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
25494 @end deftypefn";
25495 
25496 DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
25497  if (args.length() != 3) {
25498  error("swig_octave_prereq: must be called with 3 arguments");
25499  return octave_value_list();
25500  }
25501  const int major = args(0).int_value();
25502  const int minor = args(1).int_value();
25503  const int patch = args(2).int_value();
25504  const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
25505  return octave_value(prereq);
25506 }
25507 
25508 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
25509 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
25510 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
25511 @end deftypefn";
25512 
25513 void __swig_atexit__(void) { ::_Exit(0); }
25514 
25516 
25517  static octave_swig_type* module_ns = 0;
25518 
25519  // workaround to prevent octave seg-faulting on exit: set Octave exit function
25520  // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
25521  // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
25522  // version 3.4.*, but reappeared in 4.2.*, so turn on for all versions after 3.2.*.
25523  // can be turned off with macro definition.
25524 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
25525 #if SWIG_OCTAVE_PREREQ(4,4,0)
25526  atexit(__swig_atexit__);
25527 #elif SWIG_OCTAVE_PREREQ(3,2,0)
25528  octave_exit = ::_Exit;
25529 #endif
25530 #endif
25531 
25532  // check for no input and output args
25533  if (args.length() != 0 || nargout != 0) {
25534  print_usage();
25535  return octave_value_list();
25536  }
25537 
25538  // create module on first function call
25539  if (!module_ns) {
25540 
25541  // workaround bug in octave where installing global variable of custom type and then
25542  // exiting without explicitly clearing the variable causes octave to segfault.
25543 #if SWIG_OCTAVE_PREREQ(3,2,0)
25544  octave_value_list eval_args;
25545  eval_args.append("base");
25546  eval_args.append("function __swig_atexit__; "
25547  " if mislocked() "
25548  " clear -all; "
25549  " else "
25550  " mlock(); "
25551  " endif; "
25552  "endfunction; "
25553  "__swig_atexit__; "
25554  "atexit(\"__swig_atexit__\", false); "
25555  "atexit(\"__swig_atexit__\")");
25556 #if SWIG_OCTAVE_PREREQ(4,4,0)
25557  octave::feval("evalin", eval_args, 0);
25558 #else
25559  feval("evalin", eval_args, 0);
25560 #endif
25561 #endif
25562 
25563 #if SWIG_OCTAVE_PREREQ(4,4,0)
25564  {
25565  octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
25566  string_vector types = typeinfo.installed_type_names();
25567  bool register_octave_swig_ref = true;
25568  bool register_octave_swig_packed = true;
25569  bool register_octave_swig_bound_func = true;
25570  for (int i = 0; i < types.numel(); ++i) {
25571  if (types(i) == octave_swig_ref::static_type_name()) {
25572  register_octave_swig_ref = false;
25573  }
25574  if (types(i) == octave_swig_packed::static_type_name()) {
25575  register_octave_swig_packed = false;
25576  }
25577  if (types(i) == octave_swig_bound_func::static_type_name()) {
25578  register_octave_swig_bound_func = false;
25579  }
25580  }
25581  if (register_octave_swig_ref) {
25582  octave_swig_ref::register_type();
25583  }
25584  if (register_octave_swig_packed) {
25585  octave_swig_packed::register_type();
25586  }
25587  if (register_octave_swig_bound_func) {
25588  octave_swig_bound_func::register_type();
25589  }
25590  }
25591 #else
25592  octave_swig_ref::register_type();
25593  octave_swig_packed::register_type();
25594 #endif
25597 
25598 #if SWIG_OCTAVE_PREREQ(4,4,0)
25599  octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
25600  octave_function *me = stack.current();
25601 #else
25602  octave_function *me = octave_call_stack::current();
25603 #endif
25604 
25605  if (!SWIG_Octave_InstallFunction(me, "subclass")) {
25606  return octave_value_list();
25607  }
25608  if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
25609  return octave_value_list();
25610  }
25611  if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
25612  return octave_value_list();
25613  }
25614  if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
25615  return octave_value_list();
25616  }
25617  if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
25618  return octave_value_list();
25619  }
25620 
25621  octave_swig_type* cvar_ns=0;
25622  if (std::string(SWIG_global_name) != ".") {
25623  cvar_ns=new octave_swig_type;
25624  for (int j=0;swig_globals[j].name;++j)
25625  if (swig_globals[j].get_method)
25626  cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
25627  }
25628 
25629  module_ns=new octave_swig_type(0, 0, 0, true);
25630  if (std::string(SWIG_global_name) != ".") {
25631  module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
25632  }
25633  else {
25634  for (int j=0;swig_globals[j].name;++j)
25635  if (swig_globals[j].get_method)
25636  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
25637  }
25638  for (int j=0;swig_globals[j].name;++j)
25639  if (swig_globals[j].method)
25640  module_ns->assign(swig_globals[j].name,&swig_globals[j]);
25641 
25642  // * need better solution here; swig_type -> octave_class mapping is
25643  // * really n-to-1, in some cases such as template partial spec, etc.
25644  // * see failing tests.
25645  for (int j=0;swig_types[j];++j)
25646  if (swig_types[j]->clientdata) {
25647  swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
25648  module_ns->assign(c->name,
25650  (new octave_swig_type(0,swig_types[j])));
25651  }
25652 
25653  if (!SWIG_init_user(module_ns)) {
25654  delete module_ns;
25655  module_ns=0;
25656  return octave_value_list();
25657  }
25658 
25659  SWIG_InstallOps(octave_swig_ref::static_type_id());
25660 
25662  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
25663  if (mb->second.first && mb->second.first->method) {
25664  if (!SWIG_Octave_InstallFunction(me, mb->first)) {
25665  return octave_value_list();
25666  }
25667  }
25668  }
25669 
25670 #if SWIG_OCTAVE_PREREQ(4,4,0)
25671  octave::interpreter::the_interpreter()->mlock();
25672 #elif SWIG_OCTAVE_PREREQ(3,2,0)
25673  mlock();
25674 #else
25675  mlock(me->name());
25676 #endif
25677 
25678  }
25679 
25681  for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
25682  if (mb->second.second.is_defined()) {
25683  SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
25684  SWIG_Octave_LinkGlobalValue(mb->first);
25685  }
25686  }
25687 
25690 
25691  return octave_value_list();
25692 
25693 }
25694 
25695 
25696 static bool SWIG_init_user(octave_swig_type* module_ns)
25697 {
25698  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
25699  SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
25700  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
25701  SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
25702  SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
25703  SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
25704  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
25705  SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
25706  SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
25707  SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
25708  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
25709  SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
25710  SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
25711  SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
25712  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
25713  SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
25714  SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
25715  SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
25716  SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
25717  SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
25718  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
25719  SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
25720  SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
25721  SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
25722  SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
25723  SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
25724  SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
25725  SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
25726  SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
25727  SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
25728  SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
25729  SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
25730  SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
25731  SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
25732  SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
25733  SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
25734  SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
25735  SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
25736  SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
25737  SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
25738  SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
25739  SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
25740  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
25741  SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
25742  SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
25743  SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
25744  SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
25745  SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
25746  SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
25747  SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
25748  SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
25749  SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
25750  SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
25751  SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
25752  SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
25753  SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
25754  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
25755  SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
25756  SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
25757  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
25758  SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
25759  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
25760  SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
25761  SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
25762  SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
25763  SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
25764  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
25765  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
25766  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
25767  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
25768  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
25769  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
25770  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
25771  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
25772  SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
25773  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
25774  SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
25775  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
25776  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
25777  SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
25778  SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
25779  SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
25780  SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
25781  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
25782  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
25783  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
25784  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
25785  SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
25786  SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
25787  SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
25788  SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
25789  SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
25790  SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
25791  SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
25792  SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
25793  SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
25794  SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
25795  SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
25796  SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
25797  SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
25798  SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
25799  SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
25800  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
25801  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
25802  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
25803  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
25804  SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
25805  SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
25806  SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
25807  SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
25808  SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
25809  SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
25810  SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
25811  SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
25812  SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
25813  SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
25814  SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
25815  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
25816  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
25817  SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
25818  SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
25819  SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
25820  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
25821  SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
25822  SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
25823  SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
25824  SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
25825  SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
25826  SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
25827  SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
25828  SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
25829  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
25830  SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
25831  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
25832  SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
25833  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
25834  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
25835  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
25836  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
25837  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
25838  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
25839  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
25840  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
25841  SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
25842  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
25843  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
25844  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
25845  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
25846  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
25847  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
25848  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
25849  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
25850  SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
25851  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
25852  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
25853  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
25854  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
25855  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
25856  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
25857  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
25858  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
25859  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
25860  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
25861  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
25862  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
25863  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
25864  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
25865  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
25866  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
25867  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
25868  SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
25869  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
25870  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
25871  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
25872  SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
25873  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
25874  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
25875  SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
25876  SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
25877  SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
25878  SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
25879  SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
25880  SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
25881  SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
25882  SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
25883  return true;
25884 }
25885 
_wrap_plconfigtime_texinfo
static const char * _wrap_plconfigtime_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4528
pllsty
#define pllsty
Definition: plplot.h:763
octave_swig_packed::load_ascii
virtual bool load_ascii(std::istream &is)
Definition: plplot_octaveOCTAVE_wrap.cxx:2116
_wrap_plclear_texinfo
static const char * _wrap_plclear_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9023
_wrap_plgpage
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6733
_dim
static int _dim(const octave_value &o_obj, int dim_idx)
Definition: plplot_octaveOCTAVE_wrap.cxx:2540
_wrap_plot3dc_texinfo
static const char * _wrap_plot3dc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5139
swig_converter_func
void *(* swig_converter_func)(void *, int *)
Definition: plplot_octaveOCTAVE_wrap.cxx:460
swig_type_info
struct swig_type_info swig_type_info
__swig_atexit__
void __swig_atexit__(void)
Definition: plplot_octaveOCTAVE_wrap.cxx:25513
octave_swig_ref::subsref
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
Definition: plplot_octaveOCTAVE_wrap.cxx:1963
_arraylen
static int _arraylen(const octave_value &o_obj)
Definition: plplot_octaveOCTAVE_wrap.cxx:2511
_wrap_plsesc
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11164
swig_PLGraphicsIn_members
static swig_octave_member swig_PLGraphicsIn_members[]
Definition: plplot_octaveOCTAVE_wrap.cxx:16236
plsstrm
#define plsstrm
Definition: plplot.h:835
SWIG_Octave_ConvertPacked
SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type)
Definition: plplot_octaveOCTAVE_wrap.cxx:2361
_wrap_plbin
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4850
_wrap_plvect
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13086
plsdidev
#define plsdidev
Definition: plplot.h:807
_wrap_plgcol0a_texinfo
static const char * _wrap_plgcol0a_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4253
_wrap_plsyax_texinfo
static const char * _wrap_plsyax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3665
_wrap_plpat
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9349
_cvt_double_to
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
Definition: plplot_octaveOCTAVE_wrap.cxx:2563
c_plvect
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
plspage
#define plspage
Definition: plplot.h:831
SWIG_From_unsigned_SS_int
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_int(unsigned int value)
Definition: plplot_octaveOCTAVE_wrap.cxx:3368
_wrap_PLGraphicsIn_keysym_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3999
testppchar
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
Definition: plplot_octaveOCTAVE_wrap.cxx:2743
plshade
#define plshade
Definition: plplot.h:820
_wrap_PLGraphicsIn_string_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4155
plsurf3d
#define plsurf3d
Definition: plplot.h:847
subclass_usage
static const char *const subclass_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25399
_wrap_plend
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5644
_wrap_plgxax_texinfo
static const char * _wrap_plgxax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5973
_wrap_PLGraphicsIn_wX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4422
_wrap_plmtex3_texinfo
static const char * _wrap_plmtex3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3481
plssym
#define plssym
Definition: plplot.h:837
plinit
#define plinit
Definition: plplot.h:755
_wrap_plpsty
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9704
my_plimagefr2
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3267
_wrap_plsdidev
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10924
octave_swig_type::cpp_ptr::cpp_ptr
cpp_ptr(void *_ptr)
Definition: plplot_octaveOCTAVE_wrap.cxx:1094
_wrap_plschr_texinfo
static const char * _wrap_plschr_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4643
c_plot3d
void c_plot3d(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
Definition: plot3d.c:860
_wrap_pladv
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4668
octave_swig_type::own
int own
Definition: plplot_octaveOCTAVE_wrap.cxx:1102
_wrap_plcol0_texinfo
static const char * _wrap_plcol0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6039
plrandd
#define plrandd
Definition: plplot.h:787
_wrap_plsori_texinfo
static const char * _wrap_plsori_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6209
_wrap_plimagefr_texinfo
static const char * _wrap_plimagefr_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9931
_wrap_plgvpd
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7050
_wrap_plspage
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11933
_wrap_plstransform_texinfo
static const char * _wrap_plstransform_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4451
_wrap_plmeshc
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8488
octave_swig_type::is_defined
bool is_defined() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1506
plsfci
#define plsfci
Definition: plplot.h:817
_wrap_plscmap1la
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10460
octave_swig_type::subsasgn
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
Definition: plplot_octaveOCTAVE_wrap.cxx:1606
plerry
#define plerry
Definition: plplot.h:715
_wrap_plvpas_texinfo
static const char * _wrap_plvpas_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6816
_wrap_plmapfill_texinfo
static const char * _wrap_plmapfill_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10533
octave_swig_type::member_invoke
octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout)
Definition: plplot_octaveOCTAVE_wrap.cxx:1202
SWIGTYPE_p_PLGraphicsIn
#define SWIGTYPE_p_PLGraphicsIn
Definition: plplot_octaveOCTAVE_wrap.cxx:2437
SWIG_POINTER_DISOWN
#define SWIG_POINTER_DISOWN
Definition: plplot_octaveOCTAVE_wrap.cxx:321
_wrap_plsfam
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11222
_wrap_plgxax
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7154
_wrap_plscmap1la_texinfo
static const char * _wrap_plscmap1la_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7118
c_plmesh
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
Definition: plot3d.c:118
plptex3
#define plptex3
Definition: plplot.h:786
_wrap_plscmap1a
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10260
swig_typequery_usage
static const char *const swig_typequery_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25453
octave_swig_type::print
void print(std::ostream &os, bool pr_as_read_syntax=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1881
octave_swig_type::member_value_pair
std::pair< const swig_octave_member *, octave_value > member_value_pair
Definition: plplot_octaveOCTAVE_wrap.cxx:1104
my_plot3d
void my_plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, PLINT side)
Definition: plplot_octaveOCTAVE_wrap.cxx:3022
nameLabelFunc
std::string nameLabelFunc
Definition: plplot_octaveOCTAVE_wrap.cxx:2666
octave_swig_packed::octave_swig_packed
octave_swig_packed(swig_type_info *_type=0, const void *_buf=0, size_t _buf_len=0)
Definition: plplot_octaveOCTAVE_wrap.cxx:2077
SWIG_From_int
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
Definition: plplot_octaveOCTAVE_wrap.cxx:2850
_wrap_plSetOpt_texinfo
static const char * _wrap_plSetOpt_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6508
SWIG_strnlen
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
Definition: plplot_octaveOCTAVE_wrap.cxx:3420
octave_swig_packed::empty_clone
octave_base_value * empty_clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:2093
_wrap_plscmap0n
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10170
_wrap_plseed
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11142
plgspa
#define plgspa
Definition: plplot.h:743
_wrap_plscolbg
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10773
_wrap_plend1
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5656
SWIG_TypePrettyName
const SWIGRUNTIME char * SWIG_TypePrettyName(const swig_type_info *type)
Definition: plplot_octaveOCTAVE_wrap.cxx:628
SWIG_DEFUN
#define SWIG_DEFUN(cname, wname, doc)
Definition: plplot_octaveOCTAVE_wrap.cxx:872
_wrap_pljoin
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7390
_wrap_plspause
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12051
SWIG_OK
#define SWIG_OK
Definition: plplot_octaveOCTAVE_wrap.cxx:408
plstart
#define plstart
Definition: plplot.h:839
_wrap_plhist_texinfo
static const char * _wrap_plhist_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7578
my_plcont
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:2936
_wrap_plgcolbga_texinfo
static const char * _wrap_plgcolbga_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10413
_swigt__p_double
static swig_type_info _swigt__p_double
Definition: plplot_octaveOCTAVE_wrap.cxx:25030
swig_unary_op
#define swig_unary_op(name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2214
plgcolbg
#define plgcolbg
Definition: plplot.h:726
octave_swig_ref::is_map
virtual bool is_map() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1957
plsym
#define plsym
Definition: plplot.h:853
octave_swig_type::load_members
void load_members(member_map &out) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1195
_wrap_pljoin_texinfo
static const char * _wrap_pljoin_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6153
PLGraphicsIn::wX
PLFLT wX
Definition: plplot.h:443
Swig
Definition: plplot_octaveOCTAVE_wrap.cxx:967
SWIG_Octave_LoadModule
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
Definition: plplot_octaveOCTAVE_wrap.cxx:25310
plimage
#define plimage
Definition: plplot.h:753
octave_swig_packed::is_defined
bool is_defined() const
Definition: plplot_octaveOCTAVE_wrap.cxx:2097
_wrap_pllegend_texinfo
static const char * _wrap_pllegend_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4007
_wrap_PLGraphicsIn_button_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4080
plgcol0a
#define plgcol0a
Definition: plplot.h:725
_wrap_plscolbga_texinfo
static const char * _wrap_plscolbga_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10383
swig_octave_class::name
const char * name
Definition: plplot_octaveOCTAVE_wrap.cxx:1011
octave_swig_ref::ptr
octave_swig_type * ptr
Definition: plplot_octaveOCTAVE_wrap.cxx:1934
_wrap_plline
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8271
SWIG_check_num_args
SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs)
Definition: plplot_octaveOCTAVE_wrap.cxx:875
SWIG_MangledTypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplot_octaveOCTAVE_wrap.cxx:679
_wrap_PLGraphicsIn_string_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4185
_wrap_plmesh
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8408
_wrap_pl_setcontlabelformat_texinfo
static const char * _wrap_pl_setcontlabelformat_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6944
SWIG_AsVal_unsigned_SS_int
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:3346
octave_swig_type::is_map
virtual bool is_map() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1510
_wrap_plsdiplz
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11097
_wrap_plsmin_texinfo
static const char * _wrap_plsmin_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4615
_wrap_plgdiori
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6510
_wrap_plscmap1a_texinfo
static const char * _wrap_plscmap1a_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3538
pllab
#define pllab
Definition: plplot.h:757
_wrap_plOptUsage
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14448
_wrap_plarc_texinfo
static const char * _wrap_plarc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5838
swig_module_info::cast_initial
swig_cast_info ** cast_initial
Definition: plplotluacLUA_wrap.c:354
_wrap_pltimefmt_texinfo
static const char * _wrap_pltimefmt_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9220
octave_value_ref::ovl
const octave_value_list & ovl
Definition: plplot_octaveOCTAVE_wrap.cxx:2170
octave_set_immutable
SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
Definition: plplot_octaveOCTAVE_wrap.cxx:2164
_wrap_plstyl
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12718
plarc
#define plarc
Definition: plplot.h:693
_wrap_plmapline_texinfo
static const char * _wrap_plmapline_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6537
octave_swig_packed::buf
std::vector< char > buf
Definition: plplot_octaveOCTAVE_wrap.cxx:2074
_wrap_plmeridians_texinfo
static const char * _wrap_plmeridians_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9661
plprec
#define plprec
Definition: plplot.h:783
_wrap_plwind
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13440
octave_swig_ref::convert_to_str_internal
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
Definition: plplot_octaveOCTAVE_wrap.cxx:2041
_wrap_plpoin3
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9506
plsetopt
#define plsetopt
Definition: plplot.h:815
plclear
#define plclear
Definition: plplot.h:701
SWIGINTERN
#define SWIGINTERN
Definition: plplot_octaveOCTAVE_wrap.cxx:104
plschr
#define plschr
Definition: plplot.h:790
pltimefmt
#define pltimefmt
Definition: plplot.h:856
SWIG_Octave_GetModule
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
Definition: plplot_octaveOCTAVE_wrap.cxx:2410
SWIG_TypeQuery
#define SWIG_TypeQuery(name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2448
plssub
#define plssub
Definition: plplot.h:836
SWIG_Octave_NewPackedObj
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
Definition: plplot_octaveOCTAVE_wrap.cxx:2357
plctime
#define plctime
Definition: plplot.h:708
_wrap_plsdiplt
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11052
_wrap_plctime
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5544
PLBOOL
PLINT PLBOOL
Definition: plplot.h:204
octave_swig_type::cpp_ptr::destroyed
bool destroyed
Definition: plplot_octaveOCTAVE_wrap.cxx:1093
octave_swig_ref::convert_to_str
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
Definition: plplot_octaveOCTAVE_wrap.cxx:2038
_wrap_PLGraphicsIn_subwindow_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4103
my_plot3dcl
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3039
pllegend
#define pllegend
Definition: plplot.h:758
swig_type_info::dcast
swig_dycast_func dcast
Definition: plplotluacLUA_wrap.c:332
octave_swig_packed::type
swig_type_info * type
Definition: plplot_octaveOCTAVE_wrap.cxx:2073
plcolorbar
#define plcolorbar
Definition: plplot.h:704
_wrap_plstripc
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12450
swig_module_info::type_initial
swig_type_info ** type_initial
Definition: plplotluacLUA_wrap.c:353
value
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1219
swig_module_info
Definition: plplotluacLUA_wrap.c:349
_wrap_plpsty_texinfo
static const char * _wrap_plpsty_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10659
_wrap_PLGraphicsIn_state_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3976
plcont
#define plcont
Definition: plplot.h:706
octave_swig_type::member_deref
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
Definition: plplot_octaveOCTAVE_wrap.cxx:1254
swig_octave_class::base
const swig_type_info ** base
Definition: plplot_octaveOCTAVE_wrap.cxx:1019
SWIGTYPE_p_double
#define SWIGTYPE_p_double
Definition: plplot_octaveOCTAVE_wrap.cxx:2439
PLcGrid::nx
PLINT nx
Definition: plplot.h:509
octave_swig_ref::get_ptr
octave_swig_type * get_ptr() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1942
_wrap_plrandd
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9894
swig_octave_member::name
const char * name
Definition: plplot_octaveOCTAVE_wrap.cxx:997
SWIGTYPE_p_p_char
#define SWIGTYPE_p_p_char
Definition: plplot_octaveOCTAVE_wrap.cxx:2444
plscmap1
#define plscmap1
Definition: plplot.h:794
plscmap0a
#define plscmap0a
Definition: plplot.h:792
swig_cast_info::type
swig_type_info * type
Definition: plplotluacLUA_wrap.c:340
_wrap_pllightsource
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8234
plscmap1la
#define plscmap1la
Definition: plplot.h:797
_wrap_plmkstrm
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8584
_wrap_plgchr_texinfo
static const char * _wrap_plgchr_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8751
pljoin
#define pljoin
Definition: plplot.h:756
name
static const char * name
Definition: tkMain.c:135
_wrap_plbox_texinfo
static const char * _wrap_plbox_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4701
plstripd
#define plstripd
Definition: plplot.h:845
_wrap_plflush
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6119
swig_octave_prereq_usage
static const char *const swig_octave_prereq_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25491
PLUNICODE
PLUINT PLUNICODE
Definition: plplot.h:201
_wrap_plsdimap_texinfo
static const char * _wrap_plsdimap_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9117
_wrap_plsstrm_texinfo
static const char * _wrap_plsstrm_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5516
plmesh
#define plmesh
Definition: plplot.h:770
_wrap_plgspa_texinfo
static const char * _wrap_plgspa_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8408
plxormod
#define plxormod
Definition: plplot.h:865
_wrap_plmap
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13517
SWIG_OLDOBJ
#define SWIG_OLDOBJ
Definition: plplot_octaveOCTAVE_wrap.cxx:421
octave_swig_packed::save_ascii
virtual bool save_ascii(std::ostream &os)
Definition: plplot_octaveOCTAVE_wrap.cxx:2112
plvpor
#define plvpor
Definition: plplot.h:860
_wrap_plszax_texinfo
static const char * _wrap_plszax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5628
PLGraphicsIn::wY
PLFLT wY
Definition: plplot.h:443
plaxes
#define plaxes
Definition: plplot.h:694
SWIG_TypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplot_octaveOCTAVE_wrap.cxx:724
plgcolbga
#define plgcolbga
Definition: plplot.h:727
octave_swig_type::members
member_map members
Definition: plplot_octaveOCTAVE_wrap.cxx:1106
swig_module_info::next
struct swig_module_info * next
Definition: plplotluacLUA_wrap.c:352
_wrap_plbox
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5000
_wrap_plot3dc
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8812
octave_swig_ref::numeric_conversion_function
virtual type_conv_info numeric_conversion_function(void) const
Definition: plplot_octaveOCTAVE_wrap.cxx:2051
_wrap_plbop
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4988
_wrap_plenv0_texinfo
static const char * _wrap_plenv0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4928
SWIG_TypeClientData
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
Definition: plplot_octaveOCTAVE_wrap.cxx:649
_wrap_plgcolbga
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6363
plgyax
#define plgyax
Definition: plplot.h:749
_wrap_plbox3_texinfo
static const char * _wrap_plbox3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8627
_wrap_plscmap0_texinfo
static const char * _wrap_plscmap0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4394
plcol1
#define plcol1
Definition: plplot.h:703
octave_swig_type::cpp_ptr::ptr
void * ptr
Definition: plplot_octaveOCTAVE_wrap.cxx:1092
SWIG_InstallUnaryOps
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
Definition: plplot_octaveOCTAVE_wrap.cxx:2272
plgvpd
#define plgvpd
Definition: plplot.h:746
_wrap_plsdev
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10899
plpsty
#define plpsty
Definition: plplot.h:784
plmapstring
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
pltr2
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:941
_wrap_plstripa_texinfo
static const char * _wrap_plstripa_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6685
_wrap_plgcol0
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6207
_wrap_plgdidev_texinfo
static const char * _wrap_plgdidev_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4787
_wrap_plsvpa
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12839
octave_swig_type::swig_member_const_iterator
member_map::const_iterator swig_member_const_iterator
Definition: plplot_octaveOCTAVE_wrap.cxx:1428
_wrap_plinit
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7378
_wrap_plmapline
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13596
nameMapForm
std::string nameMapForm
Definition: plplot_octaveOCTAVE_wrap.cxx:2616
_wrap_PLGraphicsIn_type_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3895
plbop
#define plbop
Definition: plplot.h:696
_wrap_plpoin_texinfo
static const char * _wrap_plpoin_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7280
plsdiplt
#define plsdiplt
Definition: plplot.h:810
SWIG_PropagateClientData
SWIGRUNTIME void SWIG_PropagateClientData(void)
Definition: plplot_octaveOCTAVE_wrap.cxx:25277
_wrap_plpath
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9397
_wrap_plptex
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9726
_wrap_pltimefmt
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13039
octave_swig_type::dispatch_unary_op
static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name)
Definition: plplot_octaveOCTAVE_wrap.cxx:1807
plsurf3dl
#define plsurf3dl
Definition: plplot.h:848
SWIG_AsCharPtrAndSize
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
Definition: plplot_octaveOCTAVE_wrap.cxx:2813
my_plmesh
void my_plmesh(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt)
Definition: plplot_octaveOCTAVE_wrap.cxx:3006
plslabelfunc
#define plslabelfunc
Definition: plplot.h:825
_wrap_plhist
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7250
PLcGrid2::xg
PLFLT_NC_MATRIX xg
Definition: plplot.h:520
pl_setcontlabelparam
#define pl_setcontlabelparam
Definition: plplot.h:691
_wrap_plot3d
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8724
plgradient
#define plgradient
Definition: plplot.h:741
my_plgriddata
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:2992
plgdiori
#define plgdiori
Definition: plplot.h:731
octave_swig_type::map_value
virtual Octave_map map_value() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1723
_wrap_plscompression
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10877
_wrap_plscmap1_range
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10614
plTranslateCursor
PLINT plTranslateCursor(PLGraphicsIn *plg)
Definition: plpage.c:259
fcnLabelFunc
octave_function * fcnLabelFunc
Definition: plplot_octaveOCTAVE_wrap.cxx:2665
_wrap_plwind_texinfo
static const char * _wrap_plwind_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3859
_swigt__p_char
static swig_type_info _swigt__p_char
Definition: plplot_octaveOCTAVE_wrap.cxx:25029
_wrap_plscompression_texinfo
static const char * _wrap_plscompression_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7724
plgdiplt
#define plgdiplt
Definition: plplot.h:732
plmeridians
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
_wrap_plspal1
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12019
SWIG_Octave_AppendOutput
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
Definition: plplot_octaveOCTAVE_wrap.cxx:885
_wrap_PLGraphicsIn_wY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4503
swig_type_info::cast
struct swig_cast_info * cast
Definition: plplotluacLUA_wrap.c:333
_wrap_plstyl_texinfo
static const char * _wrap_plstyl_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5425
octave_swig_ref::subsasgn
octave_value subsasgn(const std::string &ops, const std::list< octave_value_list > &idx, const octave_value &rhs)
Definition: plplot_octaveOCTAVE_wrap.cxx:1966
plline3
#define plline3
Definition: plplot.h:762
_wrap_plglevel
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6711
octave_swig_packed::load_binary
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
Definition: plplot_octaveOCTAVE_wrap.cxx:2124
_wrap_plsfont_texinfo
static const char * _wrap_plsfont_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7845
_wrap_plgcol0a
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6259
_wrap_plgdidev
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6458
plsfam
#define plsfam
Definition: plplot.h:816
plsfnam
#define plsfnam
Definition: plplot.h:818
plflush
#define plflush
Definition: plplot.h:719
_wrap_new_PLGraphicsIn
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4526
my_plstripc
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:2888
octave_swig_ref::octave_swig_ref
octave_swig_ref(octave_swig_type *_ptr=0)
Definition: plplot_octaveOCTAVE_wrap.cxx:1936
PLGraphicsIn::string
char string[PL_MAXKEY]
Definition: plplot.h:440
_wrap_plfont
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6131
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref")
SWIG_as_voidptr
#define SWIG_as_voidptr(a)
Definition: plplot_octaveOCTAVE_wrap.cxx:2458
plgfam
#define plgfam
Definition: plplot.h:734
plsmin
#define plsmin
Definition: plplot.h:829
octave_swig_ref::default_numeric_conversion_function
static octave_base_value * default_numeric_conversion_function(const octave_base_value &a)
Definition: plplot_octaveOCTAVE_wrap.cxx:2057
_wrap_plgyax_texinfo
static const char * _wrap_plgyax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7514
swig_octave_member::is_global
bool is_global() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1005
SWIG_InstallBinaryOps
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
Definition: plplot_octaveOCTAVE_wrap.cxx:2284
_wrap_plsfont
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11306
plscolor
#define plscolor
Definition: plplot.h:804
error
static int error
Definition: plcont.c:61
SWIG_ArgError
#define SWIG_ArgError(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:411
_wrap_plpoin3_texinfo
static const char * _wrap_plpoin3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10280
_wrap_plSetUsage
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14413
_wrap_plspal0_texinfo
static const char * _wrap_plspal0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5459
SWIG_POINTER_NO_NULL
#define SWIG_POINTER_NO_NULL
Definition: plplot_octaveOCTAVE_wrap.cxx:323
_wrap_plsvect_texinfo
static const char * _wrap_plsvect_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5265
octave_swig_type::load_ascii
virtual bool load_ascii(std::istream &is)
Definition: plplot_octaveOCTAVE_wrap.cxx:1744
_wrap_plsxax_texinfo
static const char * _wrap_plsxax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8053
_wrap_plscmap1_texinfo
static const char * _wrap_plscmap1_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4486
plconfigtime
#define plconfigtime
Definition: plplot.h:705
octave_swig_type::dims
dim_vector dims(void) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1313
_wrap_PLGraphicsIn_keysym_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4028
_wrap_plslabelfunc
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11723
_wrap_plgcol0_texinfo
static const char * _wrap_plgcol0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3695
plscmap1n
#define plscmap1n
Definition: plplot.h:798
SWIG_pchar_descriptor
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
Definition: plplot_octaveOCTAVE_wrap.cxx:3400
pltext
#define pltext
Definition: plplot.h:855
_wrap_plgvpd_texinfo
static const char * _wrap_plgvpd_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7349
octave_swig_ref::string_value
virtual std::string string_value(bool force=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1975
octave_swig_type::save_ascii
virtual bool save_ascii(std::ostream &os)
Definition: plplot_octaveOCTAVE_wrap.cxx:1740
_swigt__p_f_double_double_p_double_p_double_p_void__void
static swig_type_info _swigt__p_f_double_double_p_double_p_double_p_void__void
Definition: plplot_octaveOCTAVE_wrap.cxx:25031
plgfont
#define plgfont
Definition: plplot.h:737
_wrap_plsfci_texinfo
static const char * _wrap_plsfci_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10633
nameCoordTrans
std::string nameCoordTrans
Definition: plplot_octaveOCTAVE_wrap.cxx:2700
_wrap_plbtime
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4906
c_plimagefr
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
octave_swig_type::help_text
const char * help_text() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1383
SWIG_TypeCheck
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
Definition: plplot_octaveOCTAVE_wrap.cxx:543
fcnMapForm
octave_function * fcnMapForm
Definition: plplot_octaveOCTAVE_wrap.cxx:2615
plenv
#define plenv
Definition: plplot.h:711
Swig::swig_value_deref
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
Definition: plplot_octaveOCTAVE_wrap.cxx:2192
swig_module_info::types
swig_type_info ** types
Definition: plplotluacLUA_wrap.c:350
PLGraphicsIn::pX
int pX
Definition: plplot.h:441
octave_swig_type::scalar_value
virtual double scalar_value(bool frc_str_conv=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1680
_wrap_plbox3
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5067
my_plshades
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3130
my_plcont2p
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:2979
plscmap1a
#define plscmap1a
Definition: plplot.h:795
SWIG_RUNTIME_VERSION
#define SWIG_RUNTIME_VERSION
Definition: plplot_octaveOCTAVE_wrap.cxx:287
SWIG_TypeEquiv
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
Definition: plplot_octaveOCTAVE_wrap.cxx:535
_wrap_plgfam
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6584
plstyl
#define plstyl
Definition: plplot.h:846
Swig::swig_value_deref
SWIGRUNTIME octave_swig_type * swig_value_deref(const octave_base_value &ov)
Definition: plplot_octaveOCTAVE_wrap.cxx:2204
SWIG_AsVal_int
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:2784
_wrap_plgchr
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6175
_wrap_plscmap1l
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10347
octave_swig_type::load_binary
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
Definition: plplot_octaveOCTAVE_wrap.cxx:1752
octave_swig_type::is_object
virtual bool is_object() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1658
octave_swig_ref::save_binary
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
Definition: plplot_octaveOCTAVE_wrap.cxx:2011
SWIGINTERNINLINE
#define SWIGINTERNINLINE
Definition: plplot_octaveOCTAVE_wrap.cxx:109
SWIG_Octave_SetModule
SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:2422
SWIG_Octave_GetGlobalValue
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2374
swig_octave_class
Definition: plplot_octaveOCTAVE_wrap.cxx:1010
swig_module_info
struct swig_module_info swig_module_info
_wrap_plstripc_texinfo
static const char * _wrap_plstripc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6716
_wrap_plvsta_texinfo
static const char * _wrap_plvsta_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3587
_wrap_plcont_texinfo
static const char * _wrap_plcont_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5350
_wrap_plstring_texinfo
static const char * _wrap_plstring_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4821
_wrap_plstripd_texinfo
static const char * _wrap_plstripd_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6795
_wrap_plgdev
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6437
octave_swig_packed::DECLARE_OCTAVE_ALLOCATOR
DECLARE_OCTAVE_ALLOCATOR
Definition: plplot_octaveOCTAVE_wrap.cxx:2155
_wrap_plgdiori_texinfo
static const char * _wrap_plgdiori_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8025
SWIG_TYPE_TABLE_NAME
#define SWIG_TYPE_TABLE_NAME
Definition: plplot_octaveOCTAVE_wrap.cxx:295
_wrap_plreplot_texinfo
static const char * _wrap_plreplot_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4288
_wrap_plpoin
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9450
SWIG_Octave_InstallFunction
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
Definition: plplot_octaveOCTAVE_wrap.cxx:25353
_wrap_pleop_texinfo
static const char * _wrap_pleop_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10477
octave_swig_ref
Definition: plplot_octaveOCTAVE_wrap.cxx:1933
my_plvect
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
Definition: plplot_octaveOCTAVE_wrap.cxx:3191
swig_cast_info
Definition: plplotluacLUA_wrap.c:339
_wrap_plptex_texinfo
static const char * _wrap_plptex_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5575
octave_swig_ref::scalar_value
virtual double scalar_value(bool frc_str_conv=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1978
_wrap_plvsta
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13305
_wrap_plparseopts
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9282
_wrap_plfill3
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5996
_wrap_plfontld
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6153
plgdev
#define plgdev
Definition: plplot.h:729
_wrap_plscmap0n_texinfo
static const char * _wrap_plscmap0n_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9631
_wrap_plmtex
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8606
_wrap_plsfam_texinfo
static const char * _wrap_plsfam_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7088
my_plvect1
void my_plvect1(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
Definition: plplot_octaveOCTAVE_wrap.cxx:3199
_wrap_plgcompression_texinfo
static const char * _wrap_plgcompression_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7757
SWIG_SystemError
#define SWIG_SystemError
Definition: plplot_octaveOCTAVE_wrap.cxx:862
_wrap_plenv0
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5729
octave_swig_ref::clone
octave_base_value * clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1945
_n_dims
static int _n_dims(const octave_value &o_obj)
Definition: plplot_octaveOCTAVE_wrap.cxx:2523
_wrap_pllightsource_texinfo
static const char * _wrap_pllightsource_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7883
_swigt__p_p_char
static swig_type_info _swigt__p_p_char
Definition: plplot_octaveOCTAVE_wrap.cxx:25035
plfontld
#define plfontld
Definition: plplot.h:721
plot3dcl
#define plot3dcl
Definition: plplot.h:777
octave_swig_type::dispatch_binary_op
static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name)
Definition: plplot_octaveOCTAVE_wrap.cxx:1824
_wrap_plscmap1
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10192
_wrap_plscol0a
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10720
swig_octave_class::members
const swig_octave_member * members
Definition: plplot_octaveOCTAVE_wrap.cxx:1017
_wrap_plgfam_texinfo
static const char * _wrap_plgfam_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5297
ct_func
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:2607
SWIG_ConvertPtr
#define SWIG_ConvertPtr(obj, pptr, type, flags)
Definition: plplot_octaveOCTAVE_wrap.cxx:931
SWIG_TypeError
#define SWIG_TypeError
Definition: plplot_octaveOCTAVE_wrap.cxx:857
_wrap_plot3dcl_texinfo
static const char * _wrap_plot3dcl_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3749
_wrap_plsyax
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12913
my_plGetCursor
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:2799
SWIG_Octave_SetGlobalValue
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
Definition: plplot_octaveOCTAVE_wrap.cxx:2383
plfill3
#define plfill3
Definition: plplot.h:718
DEFUN_DLD
DEFUN_DLD(subclass, args, nargout, subclass_usage)
Definition: plplot_octaveOCTAVE_wrap.cxx:25407
_wrap_plsdimap
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10969
_wrap_plstring
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12268
SWIG_ErrorType
SWIGRUNTIME octave_value SWIG_ErrorType(int code)
Definition: plplot_octaveOCTAVE_wrap.cxx:890
plrgbhls
#define plrgbhls
Definition: plplot.h:789
PLGraphicsIn
Definition: plplot.h:433
_wrap_plenv_texinfo
static const char * _wrap_plenv_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8847
_wrap_plgvpw_texinfo
static const char * _wrap_plgvpw_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8083
plszax
#define plszax
Definition: plplot.h:854
SWIGTYPE_p_unsigned_int
#define SWIGTYPE_p_unsigned_int
Definition: plplot_octaveOCTAVE_wrap.cxx:2445
_wrap_plenv
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5668
pltr1
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:874
_wrap_plgver_texinfo
static const char * _wrap_plgver_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6920
_wrap_plgdiplt_texinfo
static const char * _wrap_plgdiplt_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9822
swig_type_usage
static const char *const swig_type_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25435
octave_swig_type::convert_to_str
virtual octave_value convert_to_str(bool pad=false, bool force=false, char type='"') const
Definition: plplot_octaveOCTAVE_wrap.cxx:1781
plfont
#define plfont
Definition: plplot.h:720
plplotP.h
_wrap_plsmin
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11882
_wrap_plsfnam_texinfo
static const char * _wrap_plsfnam_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9343
_wrap_PLGraphicsIn_pY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4295
plsvect
#define plsvect
Definition: plplot.h:849
_wrap_plmtex3
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8665
octave_swig_packed::copy
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
Definition: plplot_octaveOCTAVE_wrap.cxx:2081
_wrap_plssub_texinfo
static const char * _wrap_plssub_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4426
plgcmap1_range
#define plgcmap1_range
Definition: plplot.h:723
label_func
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:2610
octave_swig_type::string_value
virtual std::string string_value(bool force=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1667
PLGraphicsIn::button
unsigned int button
Definition: plplot.h:438
_wrap_plspage_texinfo
static const char * _wrap_plspage_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7168
octave_swig_type::swig_this
long swig_this() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1378
PLPointer
void * PLPointer
Definition: plplot.h:209
_wrap_plmapstring
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13699
plResetOpts
void plResetOpts(void)
Definition: plargs.c:843
SWIG_ERROR
#define SWIG_ERROR
Definition: plplot_octaveOCTAVE_wrap.cxx:409
_wrap_plshades
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11343
_wrap_plgstrm_texinfo
static const char * _wrap_plgstrm_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6423
SWIG_AsCharArray
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
Definition: plplot_octaveOCTAVE_wrap.cxx:3375
plbin
#define plbin
Definition: plplot.h:695
swig_cast_info::converter
swig_converter_func converter
Definition: plplotluacLUA_wrap.c:341
plhlsrgb
#define plhlsrgb
Definition: plplot.h:752
_wrap_plvpas
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13207
_wrap_plstring3_texinfo
static const char * _wrap_plstring3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9753
octave_swig_type::construct_type
const swig_type_info * construct_type
Definition: plplot_octaveOCTAVE_wrap.cxx:1100
plgfnam
#define plgfnam
Definition: plplot.h:736
plfamadv
#define plfamadv
Definition: plplot.h:716
_wrap_plgradient
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6063
_wrap_pleop
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5790
_swigc__p_double
static swig_cast_info _swigc__p_double[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25052
_wrap_plerry
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5869
plparseopts
#define plparseopts
Definition: plplot.h:778
_swigc__p_f_double_double_p_double_p_double_p_void__void
static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25053
plsori
#define plsori
Definition: plplot.h:830
Xlen
static PLINT Xlen
Definition: plplot_octaveOCTAVE_wrap.cxx:2484
SWIG_TypeName
const SWIGRUNTIMEINLINE char * SWIG_TypeName(const swig_type_info *ty)
Definition: plplot_octaveOCTAVE_wrap.cxx:619
_swigc__p_p_char
static swig_cast_info _swigc__p_p_char[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25057
_wrap_plgfont_texinfo
static const char * _wrap_plgfont_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10008
_wrap_plgfci_texinfo
static const char * _wrap_plgfci_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7065
SWIG_From_long
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
Definition: plplot_octaveOCTAVE_wrap.cxx:2843
PLcGrid2::yg
PLFLT_NC_MATRIX yg
Definition: plplot.h:520
my_plshades2
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3170
_wrap_plxormod
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13485
_wrap_plstar_texinfo
static const char * _wrap_plstar_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7034
SWIG_Octave_NewPointerObj
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
Definition: plplot_octaveOCTAVE_wrap.cxx:2324
SWIG_AttributeError
#define SWIG_AttributeError
Definition: plplot_octaveOCTAVE_wrap.cxx:863
_wrap_plend1_texinfo
static const char * _wrap_plend1_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7496
plimagefr
#define plimagefr
Definition: plplot.h:754
plstar
#define plstar
Definition: plplot.h:838
_wrap_delete_PLGraphicsIn
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4539
_wrap_plstart
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12182
octave_swig_type::clone
octave_base_value * clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1494
plend1
#define plend1
Definition: plplot.h:710
plstripa
#define plstripa
Definition: plplot.h:843
_wrap_plbtime_texinfo
static const char * _wrap_plbtime_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6368
Swig::swig_value_ref
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
Definition: plplot_octaveOCTAVE_wrap.cxx:2188
plvsta
#define plvsta
Definition: plplot.h:861
octave_func
octave_value_list(* octave_func)(const octave_value_list &, int)
Definition: plplot_octaveOCTAVE_wrap.cxx:964
SWIG_name
#define SWIG_name
Definition: plplot_octaveOCTAVE_wrap.cxx:17
octave_swig_type::dispatch_unary_op
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1211
_swigt__p_int
static swig_type_info _swigt__p_int
Definition: plplot_octaveOCTAVE_wrap.cxx:25034
_wrap_plsfnam
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11281
_swigc__p_char
static swig_cast_info _swigc__p_char[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25051
_wrap_plResetOpts
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14401
plplot::PLGraphicsIn
alias _N2 PLGraphicsIn
Definition: plplot.d:1262
pleop
#define pleop
Definition: plplot.h:713
pltr0
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer PL_UNUSED(pltr_data))
Definition: plcont.c:858
_wrap_plgdev_texinfo
static const char * _wrap_plgdev_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6661
SWIGRUNTIME
#define SWIGRUNTIME
Definition: plplot_octaveOCTAVE_wrap.cxx:308
SWIG_IsNewObj
#define SWIG_IsNewObj(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:427
PLGraphicsIn::dY
PLFLT dY
Definition: plplot.h:442
octave_swig_type::octave_swig_type
octave_swig_type(const octave_swig_type &x)
plgpage
#define plgpage
Definition: plplot.h:739
plvect
#define plvect
Definition: plplot.h:858
plsdimap
#define plsdimap
Definition: plplot.h:808
my_plimagefrx
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3244
_wrap_plvpor_texinfo
static const char * _wrap_plvpor_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5539
_wrap_plsdev_texinfo
static const char * _wrap_plsdev_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9527
SWIG_AsVal_double
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:2874
_wrap_plsmaj_texinfo
static const char * _wrap_plsmaj_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6892
SWIG_TypeNewClientData
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
Definition: plplot_octaveOCTAVE_wrap.cxx:665
_wrap_plgradient_texinfo
static const char * _wrap_plgradient_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7962
plscol0a
#define plscol0a
Definition: plplot.h:801
swig_octave_class::constructor_doc
const char * constructor_doc
Definition: plplot_octaveOCTAVE_wrap.cxx:1015
pllightsource
#define pllightsource
Definition: plplot.h:759
_wrap_plmeridians
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14038
plshades
#define plshades
Definition: plplot.h:824
mapform_octave
void mapform_octave(PLINT n, PLFLT *x, PLFLT *y)
Definition: plplot_octaveOCTAVE_wrap.cxx:2618
my_plot3dc
void my_plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
Definition: plplot_octaveOCTAVE_wrap.cxx:3030
_swigc__p_f_int_double_p_char_int_p_void__void
static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25054
SWIG_AsVal_unsigned_SS_long
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:3315
_wrap_plfill3_texinfo
static const char * _wrap_plfill3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6004
_swigt__p_f_int_p_double_p_double__void
static swig_type_info _swigt__p_f_int_p_double_p_double__void
Definition: plplot_octaveOCTAVE_wrap.cxx:25033
octave_value_ref::operator*
octave_value operator*() const
Definition: plplot_octaveOCTAVE_wrap.cxx:2180
fcnCoordTrans
octave_function * fcnCoordTrans
Definition: plplot_octaveOCTAVE_wrap.cxx:2699
plgchr
#define plgchr
Definition: plplot.h:722
_wrap_plpoly3_texinfo
static const char * _wrap_plpoly3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10324
SWIG_name_usage
static const char *const SWIG_name_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25508
_wrap_PLGraphicsIn_pY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4266
PLGraphicsIn::subwindow
PLINT subwindow
Definition: plplot.h:439
my_plshade2
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3108
SWIGTYPE_p_int
#define SWIGTYPE_p_int
Definition: plplot_octaveOCTAVE_wrap.cxx:2443
xform
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plplot_octaveOCTAVE_wrap.cxx:2918
f2c
#define f2c(f, ff, nx, ny)
Definition: plplot_octaveOCTAVE_wrap.cxx:2926
_swigt__p_f_int_double_p_char_int_p_void__void
static swig_type_info _swigt__p_f_int_double_p_char_int_p_void__void
Definition: plplot_octaveOCTAVE_wrap.cxx:25032
_wrap_PLGraphicsIn_dX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4318
SWIG_IsTmpObj
#define SWIG_IsTmpObj(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:430
_wrap_plvasp_texinfo
static const char * _wrap_plvasp_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9318
SWIG_Octave_SetConstant
SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov)
Definition: plplot_octaveOCTAVE_wrap.cxx:2370
_wrap_plshades_texinfo
static const char * _wrap_plshades_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8115
plsdev
#define plsdev
Definition: plplot.h:806
defined_func
PLINT(* defined_func)(PLFLT, PLFLT)
Definition: plplot_octaveOCTAVE_wrap.cxx:2604
SWIG_Octave_ConvertPtrAndOwn
SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own)
Definition: plplot_octaveOCTAVE_wrap.cxx:2335
_wrap_plvpor
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13260
_wrap_plsdiori
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11030
_wrap_plcalc_world
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5194
swigreg_unary_op
#define swigreg_unary_op(name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2227
octave_swig_type::save_binary
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
Definition: plplot_octaveOCTAVE_wrap.cxx:1748
octave_swig_type::always_static
bool always_static
Definition: plplot_octaveOCTAVE_wrap.cxx:1107
PL_MAXKEY
#define PL_MAXKEY
Definition: plplot.h:408
_wrap_plimagefr
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14239
_wrap_PLGraphicsIn_pX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4243
SWIGRUNTIMEINLINE
#define SWIGRUNTIMEINLINE
Definition: plplot_octaveOCTAVE_wrap.cxx:312
PLGraphicsIn::keysym
unsigned int keysym
Definition: plplot.h:437
_wrap_plstring3
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12327
_wrap_plclear
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5253
plpoly3
#define plpoly3
Definition: plplot.h:782
plscolbg
#define plscolbg
Definition: plplot.h:802
_wrap_pl_setcontlabelformat
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4594
mapform_func
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
Definition: plplot_octaveOCTAVE_wrap.cxx:2608
_wrap_plglevel_texinfo
static const char * _wrap_plglevel_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9855
plseed
#define plseed
Definition: plplot.h:813
plstring
#define plstring
Definition: plplot.h:841
plplot::maxlen
integer(kind=private_plint), parameter, private maxlen
Definition: plplot.f90:48
plpath
#define plpath
Definition: plplot.h:761
_wrap_plscol0
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10675
_wrap_plscmap1_range_texinfo
static const char * _wrap_plscmap1_range_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5803
_wrap_plsdidev_texinfo
static const char * _wrap_plsdidev_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4333
PLcGrid::yg
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:508
plscolbga
#define plscolbga
Definition: plplot.h:803
_swigt__p_PLGraphicsIn
static swig_type_info _swigt__p_PLGraphicsIn
Definition: plplot_octaveOCTAVE_wrap.cxx:25028
SWIG_exception_fail
#define SWIG_exception_fail(code, msg)
Definition: plplot_octaveOCTAVE_wrap.cxx:2429
_wrap_pltext
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13027
plbox3
#define plbox3
Definition: plplot.h:698
_wrap_plgfnam
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6648
_wrap_plfontld_texinfo
static const char * _wrap_plfontld_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6478
octave_swig_type::make_value_hack
static octave_value make_value_hack(const octave_base_value &x)
Definition: plplot_octaveOCTAVE_wrap.cxx:1271
SWIG_SetModule
#define SWIG_SetModule(clientdata, pointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:945
PLcGrid
Definition: plplot.h:506
PLINT
int PLINT
Definition: plplot.h:181
octave_swig_ref::~octave_swig_ref
~octave_swig_ref()
Definition: plplot_octaveOCTAVE_wrap.cxx:1939
plcpstrm
#define plcpstrm
Definition: plplot.h:707
_wrap_plerry_texinfo
static const char * _wrap_plerry_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10599
plClearOpts
void plClearOpts(void)
Definition: plargs.c:830
_wrap_plwidth_texinfo
static const char * _wrap_plwidth_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7937
_wrap_plstart_texinfo
static const char * _wrap_plstart_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10723
SWIG_DelNewMask
#define SWIG_DelNewMask(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:426
_wrap_plscmap1n_texinfo
static const char * _wrap_plscmap1n_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4228
_wrap_plscmap0a_texinfo
static const char * _wrap_plscmap0a_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9046
SWIG_OCTAVE_BOUND_FUNC
#define SWIG_OCTAVE_BOUND_FUNC(func, args)
Definition: plplot_octaveOCTAVE_wrap.cxx:1080
PLGraphicsIn::state
unsigned int state
Definition: plplot.h:436
_wrap_plscolbga
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10810
plreplot
#define plreplot
Definition: plplot.h:788
_wrap_plrgbhls
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9919
octave_swig_type::swig_members_begin
swig_member_const_iterator swig_members_begin()
Definition: plplot_octaveOCTAVE_wrap.cxx:1429
plsmaj
#define plsmaj
Definition: plplot.h:826
my_plvect2
void my_plvect2(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg)
Definition: plplot_octaveOCTAVE_wrap.cxx:3210
plstring3
#define plstring3
Definition: plplot.h:842
plcalc_world
#define plcalc_world
Definition: plplot.h:700
plstripc
#define plstripc
Definition: plplot.h:844
swig_module
static swig_module_info swig_module
Definition: plplot_octaveOCTAVE_wrap.cxx:2447
PLcGrid2::nx
PLINT nx
Definition: plplot.h:521
octave_swig_ref::load_ascii
virtual bool load_ascii(std::istream &is)
Definition: plplot_octaveOCTAVE_wrap.cxx:2008
_wrap_plgzax_texinfo
static const char * _wrap_plgzax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10046
_wrap_plsdiplz_texinfo
static const char * _wrap_plsdiplz_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9581
octave_swig_ref::load_binary
virtual bool load_binary(std::istream &is, bool swap, oct_mach_info::float_format fmt)
Definition: plplot_octaveOCTAVE_wrap.cxx:2014
_wrap_pltext_texinfo
static const char * _wrap_pltext_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9795
plvpas
#define plvpas
Definition: plplot.h:859
_wrap_plspal1_texinfo
static const char * _wrap_plspal1_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5482
octave_swig_ref::subsref
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
Definition: plplot_octaveOCTAVE_wrap.cxx:1960
my_plcolorbar
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3283
SWIG_NEWOBJ
#define SWIG_NEWOBJ
Definition: plplot_octaveOCTAVE_wrap.cxx:422
_wrap_plGetCursor_texinfo
static const char * _wrap_plGetCursor_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6634
_wrap_plstransform
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12222
_wrap_pllegend
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7481
_wrap_plfill
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5948
_wrap_plcol1_texinfo
static const char * _wrap_plcol1_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6184
_wrap_plgra_texinfo
static const char * _wrap_plgra_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3606
_wrap_plgyax
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7186
_wrap_plline_texinfo
static const char * _wrap_plline_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7909
_wrap_plsdiplt_texinfo
static const char * _wrap_plsdiplt_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9442
_wrap_plfill_texinfo
static const char * _wrap_plfill_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5107
_wrap_plbop_texinfo
static const char * _wrap_plbop_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4368
swig_octave_class::type
swig_type_info ** type
Definition: plplot_octaveOCTAVE_wrap.cxx:1012
swig_types
static swig_type_info * swig_types[10]
Definition: plplot_octaveOCTAVE_wrap.cxx:2446
_wrap_plgfont
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6669
_wrap_PLGraphicsIn_dY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4370
_wrap_plgcolbg
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6321
_wrap_plsurf3d
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9047
SWIG_PackDataName
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
Definition: plplot_octaveOCTAVE_wrap.cxx:821
c_plcont
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
_wrap_PLGraphicsIn_type_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3924
_wrap_plbin_texinfo
static const char * _wrap_plbin_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9881
octave_swig_type::map_keys
virtual string_vector map_keys() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1728
SWIG_PackVoidPtr
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
Definition: plplot_octaveOCTAVE_wrap.cxx:797
SWIG_TMPOBJ
#define SWIG_TMPOBJ
Definition: plplot_octaveOCTAVE_wrap.cxx:423
_cvt_to_double
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
Definition: plplot_octaveOCTAVE_wrap.cxx:2587
_wrap_plseed_texinfo
static const char * _wrap_plseed_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3727
my_plshade
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3073
_wrap_plgcmap1_range
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10643
octave_swig_ref::is_string
virtual bool is_string() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1972
swig_dycast_func
struct swig_type_info *(* swig_dycast_func)(void **)
Definition: plplot_octaveOCTAVE_wrap.cxx:461
plmapline
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
Alen
static PLINT Alen
Definition: plplot_octaveOCTAVE_wrap.cxx:2483
_wrap_class_PLGraphicsIn
static swig_octave_class _wrap_class_PLGraphicsIn
Definition: plplot_octaveOCTAVE_wrap.cxx:16253
plmeshc
#define plmeshc
Definition: plplot.h:771
SWIG_AsVal_long
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:2766
_wrap_plsesc_texinfo
static const char * _wrap_plsesc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8776
plline
#define plline
Definition: plplot.h:760
plgcompression
#define plgcompression
Definition: plplot.h:728
my_plsurf3d
void my_plsurf3d(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
Definition: plplot_octaveOCTAVE_wrap.cxx:3050
c_plcolorbar
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
octave_swig_type::is_string
virtual bool is_string() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1662
my_plcont1
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:2954
_wrap_plhlsrgb
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7311
c_plshades
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
octave_swig_type::incref
void incref()
Definition: plplot_octaveOCTAVE_wrap.cxx:1369
_wrap_plshade
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11517
Ylen
static PLINT Ylen
Definition: plplot_octaveOCTAVE_wrap.cxx:2484
octave_swig_ref::DECLARE_OCTAVE_ALLOCATOR
DECLARE_OCTAVE_ALLOCATOR
Definition: plplot_octaveOCTAVE_wrap.cxx:2063
_wrap_plrandd_texinfo
static const char * _wrap_plrandd_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5327
octave_swig_type::~octave_swig_type
~octave_swig_type()
Definition: plplot_octaveOCTAVE_wrap.cxx:1295
_wrap_plscolbg_texinfo
static const char * _wrap_plscolbg_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9552
octave_swig_ref::print
void print(std::ostream &os, bool pr_as_read_syntax=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:2047
_wrap_plsym
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12942
_wrap_plssym
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12124
_wrap_plscolor
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10855
SWIG_AsVal_char
SWIGINTERN int SWIG_AsVal_char(octave_value obj, char *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:3430
plspause
#define plspause
Definition: plplot.h:834
_wrap_plprec_texinfo
static const char * _wrap_plprec_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7220
swig_octave_class::constructor
octave_func constructor
Definition: plplot_octaveOCTAVE_wrap.cxx:1014
plspal0
#define plspal0
Definition: plplot.h:832
_wrap_plline3_texinfo
static const char * _wrap_plline3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6445
my_plshades1
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3154
SWIG_Error
SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg)
Definition: plplot_octaveOCTAVE_wrap.cxx:918
octave_swig_ref::map_value
virtual Octave_map map_value() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1998
octave_swig_ref::map_keys
virtual string_vector map_keys() const
Definition: plplot_octaveOCTAVE_wrap.cxx:2002
_wrap_plw3d
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13317
PLcGrid2
Definition: plplot.h:518
_wrap_plptex3
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9790
plsesc
#define plsesc
Definition: plplot.h:814
swig_octave_class::destructor
octave_func destructor
Definition: plplot_octaveOCTAVE_wrap.cxx:1016
c_plot3dc
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
SWIG_UnpackData
const SWIGRUNTIME char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
Definition: plplot_octaveOCTAVE_wrap.cxx:769
SWIG_FromCharPtrAndSize
SWIGINTERNINLINE octave_value SWIG_FromCharPtrAndSize(const char *carray, size_t size)
Definition: plplot_octaveOCTAVE_wrap.cxx:3413
swig_octave_class::director
int director
Definition: plplot_octaveOCTAVE_wrap.cxx:1013
pltr_func
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:2606
plptex
#define plptex
Definition: plplot.h:785
swig_type_info::str
const char * str
Definition: plplotluacLUA_wrap.c:331
_wrap_plsurf3dl
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9143
octave_swig_type::subsref
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
Definition: plplot_octaveOCTAVE_wrap.cxx:1514
_wrap_PLGraphicsIn_wY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4474
plscol0
#define plscol0
Definition: plplot.h:800
plgver
#define plgver
Definition: plplot.h:745
SWIG_IndexError
#define SWIG_IndexError
Definition: plplot_octaveOCTAVE_wrap.cxx:856
_wrap_PLGraphicsIn_subwindow_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4132
octave_swig_ref::is_object
virtual bool is_object() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1969
SWIG_CAST_NEW_MEMORY
#define SWIG_CAST_NEW_MEMORY
Definition: plplot_octaveOCTAVE_wrap.cxx:322
SWIG_RuntimeError
#define SWIG_RuntimeError
Definition: plplot_octaveOCTAVE_wrap.cxx:855
plSetUsage
void plSetUsage(PLCHAR_VECTOR program_string, PLCHAR_VECTOR usage_string)
Definition: plargs.c:1287
_wrap_plgspa
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6955
swig_octave_member
Definition: plplot_octaveOCTAVE_wrap.cxx:996
SWIG_SyntaxError
#define SWIG_SyntaxError
Definition: plplot_octaveOCTAVE_wrap.cxx:860
octave_swig_type::swig_members_end
swig_member_const_iterator swig_members_end()
Definition: plplot_octaveOCTAVE_wrap.cxx:1430
SWIG_Octave_LinkGlobalValue
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2392
_wrap_plscmap1l_texinfo
static const char * _wrap_plscmap1l_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3892
PLGraphicsIn::dX
PLFLT dX
Definition: plplot.h:442
plwidth
#define plwidth
Definition: plplot.h:863
plbtime
#define plbtime
Definition: plplot.h:699
_wrap_PLGraphicsIn_pX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4214
fill_func
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
Definition: plplot_octaveOCTAVE_wrap.cxx:2605
plstransform
#define plstransform
Definition: plplot.h:840
SWIG_IOError
#define SWIG_IOError
Definition: plplot_octaveOCTAVE_wrap.cxx:854
plspal1
#define plspal1
Definition: plplot.h:833
_wrap_PLGraphicsIn_state_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:3947
octave_swig_type::find_base
const swig_type_info * find_base(const std::string &name, const swig_type_info *base)
Definition: plplot_octaveOCTAVE_wrap.cxx:1145
octave_swig_type::module
swig_module_info * module
Definition: plplot_octaveOCTAVE_wrap.cxx:1098
octave_swig_type::decref
void decref()
Definition: plplot_octaveOCTAVE_wrap.cxx:1373
plcol0
#define plcol0
Definition: plplot.h:702
my_plshadesx
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3142
c_plstripc
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
_wrap_plscolor_texinfo
static const char * _wrap_plscolor_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6611
SWIG_name_d
#define SWIG_name_d
Definition: plplot_octaveOCTAVE_wrap.cxx:16
my_plcont2
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:2965
_wrap_plline3
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8319
plgra
#define plgra
Definition: plplot.h:740
_wrap_plgpage_texinfo
static const char * _wrap_plgpage_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9180
_wrap_plpat_texinfo
static const char * _wrap_plpat_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5938
_wrap_plot3dcl
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8908
octave_value_ref
Definition: plplot_octaveOCTAVE_wrap.cxx:2169
my_plsurf3dl
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3057
swig_cast_info
struct swig_cast_info swig_cast_info
swig_globals
static const struct swig_octave_member swig_globals[]
Definition: plplot_octaveOCTAVE_wrap.cxx:24806
_wrap_plerrx
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5802
my_plmeshc
void my_plmeshc(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
Definition: plplot_octaveOCTAVE_wrap.cxx:3014
SWIG_global_name
#define SWIG_global_name
Definition: plplot_octaveOCTAVE_wrap.cxx:19
plsxax
#define plsxax
Definition: plplot.h:851
PLFLT
float PLFLT
Definition: plplot.h:163
_wrap_plcol1
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5287
_wrap_plgcompression
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6415
_wrap_plcpstrm_texinfo
static const char * _wrap_plcpstrm_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7247
plgzax
#define plgzax
Definition: plplot.h:750
_wrap_plmap_texinfo
static const char * _wrap_plmap_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6285
PLcGrid::xg
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:508
_wrap_plpoly3
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9581
_wrap_plparseopts_texinfo
static const char * _wrap_plparseopts_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6970
_swigc__p_unsigned_int
static swig_cast_info _swigc__p_unsigned_int[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25058
_wrap_plflush_texinfo
static const char * _wrap_plflush_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8008
_wrap_plcalc_world_texinfo
static const char * _wrap_plcalc_world_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8572
octave_swig_ref::save_ascii
virtual bool save_ascii(std::ostream &os)
Definition: plplot_octaveOCTAVE_wrap.cxx:2005
octave_swig_type
Definition: plplot_octaveOCTAVE_wrap.cxx:1090
SWIG_TypeCast
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
Definition: plplot_octaveOCTAVE_wrap.cxx:597
octave_swig_type::types
std::vector< type_ptr_pair > types
Definition: plplot_octaveOCTAVE_wrap.cxx:1101
plgcol0
#define plgcol0
Definition: plplot.h:724
SWIG_TypeDynamicCast
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
Definition: plplot_octaveOCTAVE_wrap.cxx:605
plsfont
#define plsfont
Definition: plplot.h:819
plw3d
#define plw3d
Definition: plplot.h:862
swig_module_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:355
SWIG_InstallOps
SWIGRUNTIME void SWIG_InstallOps(int tid)
Definition: plplot_octaveOCTAVE_wrap.cxx:2311
_wrap_plscol0a_texinfo
static const char * _wrap_plscol0a_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3629
_wrap_plprec
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9675
_wrap_plend_texinfo
static const char * _wrap_plend_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7631
swig_module_info::size
size_t size
Definition: plplotluacLUA_wrap.c:351
octave_swig_type::dispatch_binary_op
bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1225
SWIG_as_voidptrptr
#define SWIG_as_voidptrptr(a)
Definition: plplot_octaveOCTAVE_wrap.cxx:2459
_wrap_plmtex_texinfo
static const char * _wrap_plmtex_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5208
_wrap_plmkstrm_texinfo
static const char * _wrap_plmkstrm_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9152
PLcGrid::ny
PLINT ny
Definition: plplot.h:509
SWIG_AddCast
#define SWIG_AddCast(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:449
swig_cast_info::prev
struct swig_cast_info * prev
Definition: plplotluacLUA_wrap.c:343
_wrap_pl_setcontlabelparam
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4623
_wrap_plgstrm
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7007
_wrap_plgver
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7029
octave_swig_type::as_value
octave_value as_value()
Definition: plplot_octaveOCTAVE_wrap.cxx:1364
_wrap_plgdiplt
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6532
SWIG_TypeNameComp
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
Definition: plplot_octaveOCTAVE_wrap.cxx:501
octave_swig_type::assign
void assign(const std::string &name, const swig_octave_member *m)
Definition: plplot_octaveOCTAVE_wrap.cxx:1490
_wrap_plwidth
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13418
c_plmeshc
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
plgvpw
#define plgvpw
Definition: plplot.h:747
_wrap_PLGraphicsIn_dY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4399
_wrap_plvect_texinfo
static const char * _wrap_plvect_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9369
_wrap_plgzax
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7218
_wrap_pladv_texinfo
static const char * _wrap_pladv_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7780
plmkstrm
#define plmkstrm
Definition: plplot.h:772
plhist
#define plhist
Definition: plplot.h:751
_wrap_plcolorbar_texinfo
static const char * _wrap_plcolorbar_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8229
_swigt__p_unsigned_int
static swig_type_info _swigt__p_unsigned_int
Definition: plplot_octaveOCTAVE_wrap.cxx:25036
_wrap_plgfci
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6626
plsvpa
#define plsvpa
Definition: plplot.h:850
plgriddata
#define plgriddata
Definition: plplot.h:742
max
int max(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2493
SWIG_CheckState
#define SWIG_CheckState(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:450
swig_binary_op
#define swig_binary_op(name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2218
octave_swig_type::assign
void assign(const std::string &name, const octave_value &ov)
Definition: plplot_octaveOCTAVE_wrap.cxx:1486
_wrap_plsfci
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11259
_wrap_plaxes_texinfo
static const char * _wrap_plaxes_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10161
plsdiplz
#define plsdiplz
Definition: plplot.h:811
octave_swig_packed::save_binary
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
Definition: plplot_octaveOCTAVE_wrap.cxx:2120
SWIG_From_double
SWIGINTERNINLINE octave_value SWIG_From_double(double value)
Definition: plplot_octaveOCTAVE_wrap.cxx:2856
plwind
#define plwind
Definition: plplot.h:864
_wrap_plerrx_texinfo
static const char * _wrap_plerrx_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10443
plbox
#define plbox
Definition: plplot.h:697
swig_octave_member::get_method
octave_func get_method
Definition: plplot_octaveOCTAVE_wrap.cxx:999
labelfunc_octave
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
Definition: plplot_octaveOCTAVE_wrap.cxx:2668
_wrap_plmaptex
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13813
ct_octave
void ct_octave(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
Definition: plplot_octaveOCTAVE_wrap.cxx:2702
_wrap_plschr
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9986
swig_cast_info::next
struct swig_cast_info * next
Definition: plplotluacLUA_wrap.c:342
plOptUsage
void plOptUsage(void)
Definition: plargs.c:1304
octave_swig_ref::dims
dim_vector dims(void) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1951
_wrap_plgvpw
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7102
_wrap_plcpstrm
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5615
_wrap_plvasp
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13064
swig_octave_member::flags
int flags
Definition: plplot_octaveOCTAVE_wrap.cxx:1001
octave_swig_type::find_member
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
Definition: plplot_octaveOCTAVE_wrap.cxx:1132
swig_type_info::owndata
int owndata
Definition: plplotluacLUA_wrap.c:335
_wrap_plstripd
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12696
_wrap_plsori
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11911
_wrap_plszax
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12998
octave_swig_packed::DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
Definition: plplot_octaveOCTAVE_wrap.cxx:2157
octave_swig_type::cpp_ptr
Definition: plplot_octaveOCTAVE_wrap.cxx:1091
my_plimagefr
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3235
_wrap_plsstrm
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12073
plot3d
#define plot3d
Definition: plplot.h:775
SWIG_UnpackVoidPtr
const SWIGRUNTIME char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
Definition: plplot_octaveOCTAVE_wrap.cxx:808
_wrap_pllsty
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8386
_wrap_plreplot
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9907
SWIG_DivisionByZero
#define SWIG_DivisionByZero
Definition: plplot_octaveOCTAVE_wrap.cxx:858
_wrap_PLGraphicsIn_wX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4451
_wrap_plssym_texinfo
static const char * _wrap_plssym_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10695
plmap
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
octave_swig_type::member_map
std::map< std::string, member_value_pair > member_map
Definition: plplot_octaveOCTAVE_wrap.cxx:1105
octave_swig_type::swig_type_name
std::string swig_type_name() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1392
_swigc__p_PLGraphicsIn
static swig_cast_info _swigc__p_PLGraphicsIn[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25050
_wrap_plconfigtime
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5309
octave_swig_type::merge
void merge(octave_swig_type &rhs)
Definition: plplot_octaveOCTAVE_wrap.cxx:1408
_wrap_plstar
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12153
plpoin3
#define plpoin3
Definition: plplot.h:781
octave_swig_type::operator=
octave_swig_type & operator=(const octave_swig_type &rhs)
_wrap_plaxes
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4767
_wrap_plptex3_texinfo
static const char * _wrap_plptex3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10075
_wrap_pl_setcontlabelparam_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7813
_wrap_plspal0
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11994
_wrap_plot3d_texinfo
static const char * _wrap_plot3d_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5879
octave_swig_type::convert_to_str_internal
virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1785
swig_type_info::name
const char * name
Definition: plplotluacLUA_wrap.c:330
_wrap_plsmaj
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11769
_wrap_plgra
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6805
octave_swig_ref::DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
Definition: plplot_octaveOCTAVE_wrap.cxx:2065
plscmap1_range
#define plscmap1_range
Definition: plplot.h:799
SWIG_OverflowError
#define SWIG_OverflowError
Definition: plplot_octaveOCTAVE_wrap.cxx:859
plmtex3
#define plmtex3
Definition: plplot.h:774
buf
static char buf[200]
Definition: tclAPI.c:873
_wrap_plsurf3dl_texinfo
static const char * _wrap_plsurf3dl_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5658
DEFINE_OCTAVE_ALLOCATOR
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
swig_cast_initial
static swig_cast_info * swig_cast_initial[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25060
swig_octave_member::is_static
bool is_static() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1003
pladv
#define pladv
Definition: plplot.h:692
_wrap_plrgbhls_texinfo
static const char * _wrap_plrgbhls_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9716
swig_octave_member::method
octave_func method
Definition: plplot_octaveOCTAVE_wrap.cxx:998
_wrap_plpath_texinfo
static const char * _wrap_plpath_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8812
_wrap_plcolorbar
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7937
octave_value_ref::j
int j
Definition: plplot_octaveOCTAVE_wrap.cxx:2171
_wrap_plsxax
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12884
SWIG_UnpackDataName
const SWIGRUNTIME char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
Definition: plplot_octaveOCTAVE_wrap.cxx:836
plGetCursor
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
SWIG_TypeCheckStruct
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
Definition: plplot_octaveOCTAVE_wrap.cxx:570
c_plot3dcl
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
plvasp
#define plvasp
Definition: plplot.h:857
_wrap_plinit_texinfo
static const char * _wrap_plinit_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4674
_wrap_plarc
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4690
plscmap0n
#define plscmap0n
Definition: plplot.h:793
octave_swig_type::type_ptr_pair
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
Definition: plplot_octaveOCTAVE_wrap.cxx:1096
SWIG_IsOK
#define SWIG_IsOK(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:410
swig_PLGraphicsIn_base
static const swig_type_info * swig_PLGraphicsIn_base[]
Definition: plplot_octaveOCTAVE_wrap.cxx:16252
pl_setcontlabelformat
#define pl_setcontlabelformat
Definition: plplot.h:690
text
static int text
Definition: ps.c:77
plpoin
#define plpoin
Definition: plplot.h:780
SWIG_ValueError
#define SWIG_ValueError
Definition: plplot_octaveOCTAVE_wrap.cxx:861
swig_octave_member::doc
const char * doc
Definition: plplot_octaveOCTAVE_wrap.cxx:1002
my_plcont0
void my_plcont0(const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel)
Definition: plplot_octaveOCTAVE_wrap.cxx:2945
octave_swig_ref::is_defined
bool is_defined() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1954
plscmap0
#define plscmap0
Definition: plplot.h:791
_wrap_plgcolbg_texinfo
static const char * _wrap_plgcolbg_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10252
SWIG_op_prefix
#define SWIG_op_prefix
Definition: plplot_octaveOCTAVE_wrap.cxx:20
my_plshade1
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3089
c_plsurf3dl
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
octave_swig_type::dispatch_global_op
static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret)
Definition: plplot_octaveOCTAVE_wrap.cxx:1789
_wrap_PLGraphicsIn_dX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4347
_wrap_plscmap1n
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10592
octave_swig_ref::empty_clone
octave_base_value * empty_clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1948
SWIG_InitializeModule
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
Definition: plplot_octaveOCTAVE_wrap.cxx:25129
plpat
#define plpat
Definition: plplot.h:779
_wrap_plgriddata
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6817
octave_swig_packed
Definition: plplot_octaveOCTAVE_wrap.cxx:2072
_wrap_plsvect
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12766
octave_swig_type::cast
int cast(void **vptr, swig_type_info *type, int *_own, int flags)
Definition: plplot_octaveOCTAVE_wrap.cxx:1432
plgxax
#define plgxax
Definition: plplot.h:748
swig_octave_class::base_names
const char ** base_names
Definition: plplot_octaveOCTAVE_wrap.cxx:1018
SWIG_From_unsigned_SS_long
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
Definition: plplot_octaveOCTAVE_wrap.cxx:3361
c_plshade
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
_wrap_plgriddata_texinfo
static const char * _wrap_plgriddata_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8945
octave_swig_type::is_owned
bool is_owned() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1468
_wrap_plsdiori_texinfo
static const char * _wrap_plsdiori_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7543
SWIG_init_user
static bool SWIG_init_user(octave_swig_type *module_ns)
Definition: plplot_octaveOCTAVE_wrap.cxx:25696
SWIG_POINTER_OWN
#define SWIG_POINTER_OWN
Definition: plplot_octaveOCTAVE_wrap.cxx:326
plenv0
#define plenv0
Definition: plplot.h:712
octave_value_ref::octave_value_ref
octave_value_ref(const octave_value_list &_ovl, int _j)
Definition: plplot_octaveOCTAVE_wrap.cxx:2173
SWIG_NewPointerObj
#define SWIG_NewPointerObj(ptr, type, flags)
Definition: plplot_octaveOCTAVE_wrap.cxx:932
octave_swig_type::load_members
void load_members(const swig_octave_class *c, member_map &out) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1174
_wrap_plfont_texinfo
static const char * _wrap_plfont_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5744
swig_this_usage
static const char *const swig_this_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25471
octave_swig_type::find_member
const swig_octave_member * find_member(const swig_type_info *type, const std::string &name)
Definition: plplot_octaveOCTAVE_wrap.cxx:1109
_wrap_plslabelfunc_texinfo
static const char * _wrap_plslabelfunc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6855
_wrap_plfamadv_texinfo
static const char * _wrap_plfamadv_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9614
SWIG_fail
#define SWIG_fail
Definition: plplot_octaveOCTAVE_wrap.cxx:926
_wrap_plGetCursor
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14518
_wrap_plsurf3d_texinfo
static const char * _wrap_plsurf3d_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7654
SWIG_PackData
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
Definition: plplot_octaveOCTAVE_wrap.cxx:753
_wrap_pllab_texinfo
static const char * _wrap_pllab_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4305
octave_swig_type::octave_swig_type
octave_swig_type(void *_ptr=0, const swig_type_info *_type=0, int _own=0, bool _always_static=false)
Definition: plplot_octaveOCTAVE_wrap.cxx:1280
_wrap_plClearOpts
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14389
octave_swig_type::dispatch_index_op
bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1240
_wrap_plscmap0
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10015
_swigc__p_f_int_p_double_p_double__void
static swig_cast_info _swigc__p_f_int_p_double_p_double__void[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25055
_wrap_plcol0
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5265
octave_swig_type::subsref
virtual octave_value_list subsref(const std::string &ops, const std::list< octave_value_list > &idx, int nargout)
Definition: plplot_octaveOCTAVE_wrap.cxx:1519
plot3dc
#define plot3dc
Definition: plplot.h:776
_wrap_plmapstring_texinfo
static const char * _wrap_plmapstring_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4859
swigreg_binary_op
#define swigreg_binary_op(name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2236
_wrap_plctime_texinfo
static const char * _wrap_plctime_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6234
_wrap_plmapfill
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13935
plmapfill
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
_wrap_plgfnam_texinfo
static const char * _wrap_plgfnam_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3836
_wrap_plsvpa_texinfo
static const char * _wrap_plsvpa_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3447
_wrap_plscmap0a
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10083
_wrap_plxormod_texinfo
static const char * _wrap_plxormod_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7320
_wrap_pllsty_texinfo
static const char * _wrap_pllsty_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9471
plmaptex
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
octave_swig_type::empty_clone
octave_base_value * empty_clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1502
SWIG_NullReferenceError
#define SWIG_NullReferenceError
Definition: plplot_octaveOCTAVE_wrap.cxx:865
PLGraphicsIn::pY
int pY
Definition: plplot.h:441
SWIG_MemoryError
#define SWIG_MemoryError
Definition: plplot_octaveOCTAVE_wrap.cxx:864
c_plsurf3d
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
SWIG_OCTAVE_PREREQ
#define SWIG_OCTAVE_PREREQ(major, minor, patch)
Definition: plplot_octaveOCTAVE_wrap.cxx:180
my_plimagefr1
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3254
f2eval_func
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:2609
_wrap_pllab
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7435
swig_PLGraphicsIn_base_names
static const char * swig_PLGraphicsIn_base_names[]
Definition: plplot_octaveOCTAVE_wrap.cxx:16251
plfill
#define plfill
Definition: plplot.h:717
_wrap_plcont
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5410
plsyax
#define plsyax
Definition: plplot.h:852
octave_swig_packed::clone
octave_base_value * clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:2089
plglevel
#define plglevel
Definition: plplot.h:738
_wrap_plshade_texinfo
static const char * _wrap_plshade_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8442
plgdidev
#define plgdidev
Definition: plplot.h:730
swig_type_info
Definition: plplotluacLUA_wrap.c:329
plerrx
#define plerrx
Definition: plplot.h:714
_wrap_plmesh_texinfo
static const char * _wrap_plmesh_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7381
octave_swig_packed::print
void print(std::ostream &os, bool pr_as_read_syntax=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:2104
plscompression
#define plscompression
Definition: plplot.h:805
_wrap_plfamadv
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5936
plgfci
#define plgfci
Definition: plplot.h:735
_wrap_plhlsrgb_texinfo
static const char * _wrap_plhlsrgb_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10495
_wrap_plsym_texinfo
static const char * _wrap_plsym_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9496
swig_type_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:334
_wrap_plmeshc_texinfo
static const char * _wrap_plmeshc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7433
SWIG_GetModule
#define SWIG_GetModule(clientdata)
Definition: plplot_octaveOCTAVE_wrap.cxx:944
_wrap_plspause_texinfo
static const char * _wrap_plspause_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3984
plsdiori
#define plsdiori
Definition: plplot.h:809
swig_type_initial
static swig_type_info * swig_type_initial[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25038
_wrap_plscol0_texinfo
static const char * _wrap_plscol0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9082
SWIG_TypeCmp
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
Definition: plplot_octaveOCTAVE_wrap.cxx:516
plscmap1l
#define plscmap1l
Definition: plplot.h:796
swig_octave_member::set_method
octave_func set_method
Definition: plplot_octaveOCTAVE_wrap.cxx:1000
_wrap_PLGraphicsIn_button_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4051
my_plimage
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)
Definition: plplot_octaveOCTAVE_wrap.cxx:3224
_wrap_plssub
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12095
my_plTranslateCursor
static int my_plTranslateCursor(PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in)
Definition: plplot_octaveOCTAVE_wrap.cxx:2863
plmtex
#define plmtex
Definition: plplot.h:773
PLcGrid2::ny
PLINT ny
Definition: plplot.h:521
_wrap_plstripa
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12405
plgstrm
#define plgstrm
Definition: plplot.h:744
plend
#define plend
Definition: plplot.h:709
_swigc__p_int
static swig_cast_info _swigc__p_int[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25056
_wrap_plw3d_texinfo
static const char * _wrap_plw3d_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5026
min
int min(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2497
_wrap_plmaptex_texinfo
static const char * _wrap_plmaptex_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6080
_wrap_plgcmap1_range_texinfo
static const char * _wrap_plgcmap1_range_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5777