PLplot: plplot_octaveOCTAVE_wrap.cxx Source File

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 3.0.12
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11
12 #ifndef SWIGOCTAVE
13 #define SWIGOCTAVE
14 #endif
15
16 #define SWIG_name_d "plplot_octave"
17 #define SWIG_name plplot_octave
18
19 #define SWIG_global_name "cvar"
20 #define SWIG_op_prefix "op_"
21
22
23 #ifdef __cplusplus
24 /* SwigValueWrapper is described in swig.swg */
25 template<typename T> class SwigValueWrapper {
26 struct SwigMovePointer {
27 T *ptr;
28 SwigMovePointer(T *p) : ptr(p) { }
29 ~SwigMovePointer() { delete ptr; }
30 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
31 } pointer;
32 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
33 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
34 public:
35 SwigValueWrapper() : pointer(0) { }
36 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
37 operator T&() const { return *pointer.ptr; }
38 T *operator&() { return pointer.ptr; }
39 };
40
41 template <typename T> T SwigValueInit() {
42 return T();
43 }
44 #endif
45
46 /* -----------------------------------------------------------------------------
47 * This section contains generic SWIG labels for method/variable
48 * declarations/attributes, and other compiler dependent labels.
49 * ----------------------------------------------------------------------------- */
50
51 /* template workaround for compilers that cannot correctly implement the C++ standard */
52 #ifndef SWIGTEMPLATEDISAMBIGUATOR
53 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # elif defined(__HP_aCC)
56 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
57 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
58 # define SWIGTEMPLATEDISAMBIGUATOR template
59 # else
60 # define SWIGTEMPLATEDISAMBIGUATOR
61 # endif
62 #endif
63
64 /* inline attribute */
65 #ifndef SWIGINLINE
66 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
67 # define SWIGINLINE inline
68 # else
69 # define SWIGINLINE
70 # endif
71 #endif
72
73 /* attribute recognised by some compilers to avoid 'unused' warnings */
74 #ifndef SWIGUNUSED
75 # if defined(__GNUC__)
76 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
77 # define SWIGUNUSED __attribute__ ((__unused__))
78 # else
79 # define SWIGUNUSED
80 # endif
81 # elif defined(__ICC)
82 # define SWIGUNUSED __attribute__ ((__unused__))
83 # else
84 # define SWIGUNUSED
85 # endif
86 #endif
87
88 #ifndef SWIG_MSC_UNSUPPRESS_4505
89 # if defined(_MSC_VER)
90 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
91 # endif
92 #endif
93
94 #ifndef SWIGUNUSEDPARM
95 # ifdef __cplusplus
96 # define SWIGUNUSEDPARM(p)
97 # else
98 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
99 # endif
100 #endif
101
102 /* internal SWIG method */
103 #ifndef SWIGINTERN
104 # define SWIGINTERN static SWIGUNUSED
105 #endif
106
107 /* internal inline SWIG method */
108 #ifndef SWIGINTERNINLINE
109 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
110 #endif
111
112 /* exporting methods */
113 #if defined(__GNUC__)
114 # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
115 # ifndef GCC_HASCLASSVISIBILITY
116 # define GCC_HASCLASSVISIBILITY
117 # endif
118 # endif
119 #endif
120
121 #ifndef SWIGEXPORT
122 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
123 # if defined(STATIC_LINKED)
124 # define SWIGEXPORT
125 # else
126 # define SWIGEXPORT __declspec(dllexport)
127 # endif
128 # else
129 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
130 # define SWIGEXPORT __attribute__ ((visibility("default")))
131 # else
132 # define SWIGEXPORT
133 # endif
134 # endif
135 #endif
136
137 /* calling conventions for Windows */
138 #ifndef SWIGSTDCALL
139 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
140 # define SWIGSTDCALL __stdcall
141 # else
142 # define SWIGSTDCALL
143 # endif
144 #endif
145
146 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
147 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
148 # define _CRT_SECURE_NO_DEPRECATE
149 #endif
150
151 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
152 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
153 # define _SCL_SECURE_NO_DEPRECATE
154 #endif
155
156 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
157 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
158 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
159 #endif
160
161 /* Intel's compiler complains if a variable which was never initialised is
162 * cast to void, which is a common idiom which we use to indicate that we
163 * are aware a variable isn't used. So we just silence that warning.
164 * See: https://github.com/swig/swig/issues/192 for more discussion.
165 */
166 #ifdef __INTEL_COMPILER
167 # pragma warning disable 592
168 #endif
169
170
171
172 #include <cstdlib>
173 #include <iostream>
174
175 #include <octave/oct.h>
176 #include <octave/version.h>
177
178 // Macro for enabling features which require Octave version >= major.minor.patch
179 // - Use (OCTAVE_PATCH_VERSION + 0) to handle both '<digit>' (released) and '<digit>+' (in development) patch numbers
180 #define SWIG_OCTAVE_PREREQ(major, minor, patch) \
181 ( (OCTAVE_MAJOR_VERSION<<16) + (OCTAVE_MINOR_VERSION<<8) + (OCTAVE_PATCH_VERSION + 0) >= ((major)<<16) + ((minor)<<8) + (patch) )
182
183 // Reconstruct Octave major, minor, and patch versions for releases prior to 3.8.1
184 #if !defined(OCTAVE_MAJOR_VERSION)
185
186 # if !defined(OCTAVE_API_VERSION_NUMBER)
187
188 // Hack to distinguish between Octave 3.8.0, which removed OCTAVE_API_VERSION_NUMBER but did not yet
189 // introduce OCTAVE_MAJOR_VERSION, and Octave <= 3.2, which did not define OCTAVE_API_VERSION_NUMBER
190 # include <octave/ov.h>
191 # if defined(octave_ov_h)
192 # define OCTAVE_MAJOR_VERSION 3
193 # define OCTAVE_MINOR_VERSION 8
194 # define OCTAVE_PATCH_VERSION 0
195 # else
196
197 // Hack to distinguish between Octave 3.2 and earlier versions, before OCTAVE_API_VERSION_NUMBER existed
198 # define ComplexLU __ignore
199 # include <octave/CmplxLU.h>
200 # undef ComplexLU
201 # if defined(octave_Complex_LU_h)
202
203 // We know only that this version is prior to Octave 3.2, i.e. OCTAVE_API_VERSION_NUMBER < 37
204 # define OCTAVE_MAJOR_VERSION 3
205 # define OCTAVE_MINOR_VERSION 1
206 # define OCTAVE_PATCH_VERSION 99
207
208 # else
209
210 // OCTAVE_API_VERSION_NUMBER == 37
211 # define OCTAVE_MAJOR_VERSION 3
212 # define OCTAVE_MINOR_VERSION 2
213 # define OCTAVE_PATCH_VERSION 0
214
215 # endif // defined(octave_Complex_LU_h)
216
217 # endif // defined(octave_ov_h)
218
219 // Correlation between Octave API and version numbers extracted from Octave's
220 // ChangeLogs; version is the *earliest* released Octave with that API number
221 # elif OCTAVE_API_VERSION_NUMBER >= 48
222 # define OCTAVE_MAJOR_VERSION 3
223 # define OCTAVE_MINOR_VERSION 6
224 # define OCTAVE_PATCH_VERSION 0
225
226 # elif OCTAVE_API_VERSION_NUMBER >= 45
227 # define OCTAVE_MAJOR_VERSION 3
228 # define OCTAVE_MINOR_VERSION 4
229 # define OCTAVE_PATCH_VERSION 1
230
231 # elif OCTAVE_API_VERSION_NUMBER >= 42
232 # define OCTAVE_MAJOR_VERSION 3
233 # define OCTAVE_MINOR_VERSION 3
234 # define OCTAVE_PATCH_VERSION 54
235
236 # elif OCTAVE_API_VERSION_NUMBER >= 41
237 # define OCTAVE_MAJOR_VERSION 3
238 # define OCTAVE_MINOR_VERSION 3
239 # define OCTAVE_PATCH_VERSION 53
240
241 # elif OCTAVE_API_VERSION_NUMBER >= 40
242 # define OCTAVE_MAJOR_VERSION 3
243 # define OCTAVE_MINOR_VERSION 3
244 # define OCTAVE_PATCH_VERSION 52
245
246 # elif OCTAVE_API_VERSION_NUMBER >= 39
247 # define OCTAVE_MAJOR_VERSION 3
248 # define OCTAVE_MINOR_VERSION 3
249 # define OCTAVE_PATCH_VERSION 51
250
251 # else // OCTAVE_API_VERSION_NUMBER == 38
252 # define OCTAVE_MAJOR_VERSION 3
253 # define OCTAVE_MINOR_VERSION 3
254 # define OCTAVE_PATCH_VERSION 50
255
256 # endif // !defined(OCTAVE_API_VERSION_NUMBER)
257
258 #endif // !defined(OCTAVE_MAJOR_VERSION)
259
260 #include <octave/Cell.h>
261 #include <octave/dynamic-ld.h>
262 #include <octave/oct-env.h>
263 #include <octave/oct-map.h>
264 #include <octave/ov-scalar.h>
265 #include <octave/ov-fcn-handle.h>
266 #include <octave/parse.h>
267 #if SWIG_OCTAVE_PREREQ(4,2,0)
268 #include <octave/interpreter.h>
269 #else
270 #include <octave/toplev.h>
271 #endif
272 #include <octave/unwind-prot.h>
273 #if SWIG_OCTAVE_PREREQ(4,2,0)
274 #include <octave/call-stack.h>
275 #endif
276
277
278 /* -----------------------------------------------------------------------------
279 * swigrun.swg
280 *
281 * This file contains generic C API SWIG runtime support for pointer
282 * type checking.
283 * ----------------------------------------------------------------------------- */
284
285 /* This should only be incremented when either the layout of swig_type_info changes,
286 or for whatever reason, the runtime changes incompatibly */
287 #define SWIG_RUNTIME_VERSION "4"
288
289 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
290 #ifdef SWIG_TYPE_TABLE
291 # define SWIG_QUOTE_STRING(x) #x
292 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
293 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
294 #else
295 # define SWIG_TYPE_TABLE_NAME
296 #endif
297
298 /*
299 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
300 creating a static or dynamic library from the SWIG runtime code.
301 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
302
303 But only do this if strictly necessary, ie, if you have problems
304 with your compiler or suchlike.
305 */
306
307 #ifndef SWIGRUNTIME
308 # define SWIGRUNTIME SWIGINTERN
309 #endif
310
311 #ifndef SWIGRUNTIMEINLINE
312 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
313 #endif
314
315 /* Generic buffer size */
316 #ifndef SWIG_BUFFER_SIZE
317 # define SWIG_BUFFER_SIZE 1024
318 #endif
319
320 /* Flags for pointer conversions */
321 #define SWIG_POINTER_DISOWN 0x1
322 #define SWIG_CAST_NEW_MEMORY 0x2
323
324 /* Flags for new pointer objects */
325 #define SWIG_POINTER_OWN 0x1
326
327
328 /*
329 Flags/methods for returning states.
330
331 The SWIG conversion methods, as ConvertPtr, return an integer
332 that tells if the conversion was successful or not. And if not,
333 an error code can be returned (see swigerrors.swg for the codes).
334
335 Use the following macros/flags to set or process the returning
336 states.
337
338 In old versions of SWIG, code such as the following was usually written:
339
340 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
341 // success code
342 } else {
343 //fail code
344 }
345
346 Now you can be more explicit:
347
348 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
349 if (SWIG_IsOK(res)) {
350 // success code
351 } else {
352 // fail code
353 }
354
355 which is the same really, but now you can also do
356
357 Type *ptr;
358 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
359 if (SWIG_IsOK(res)) {
360 // success code
361 if (SWIG_IsNewObj(res) {
362 ...
363 delete *ptr;
364 } else {
365 ...
366 }
367 } else {
368 // fail code
369 }
370
371 I.e., now SWIG_ConvertPtr can return new objects and you can
372 identify the case and take care of the deallocation. Of course that
373 also requires SWIG_ConvertPtr to return new result values, such as
374
375 int SWIG_ConvertPtr(obj, ptr,...) {
376 if (<obj is ok>) {
377 if (<need new object>) {
378 *ptr = <ptr to new allocated object>;
379 return SWIG_NEWOBJ;
380 } else {
381 *ptr = <ptr to old object>;
382 return SWIG_OLDOBJ;
383 }
384 } else {
385 return SWIG_BADOBJ;
386 }
387 }
388
389 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
390 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
391 SWIG errors code.
392
393 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
394 allows to return the 'cast rank', for example, if you have this
395
396 int food(double)
397 int fooi(int);
398
399 and you call
400
401 food(1) // cast rank '1' (1 -> 1.0)
402 fooi(1) // cast rank '0'
403
404 just use the SWIG_AddCast()/SWIG_CheckState()
405 */
406
407 #define SWIG_OK (0)
408 #define SWIG_ERROR (-1)
409 #define SWIG_IsOK(r) (r >= 0)
410 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
411
412 /* The CastRankLimit says how many bits are used for the cast rank */
413 #define SWIG_CASTRANKLIMIT (1 << 8)
414 /* The NewMask denotes the object was created (using new/malloc) */
415 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
416 /* The TmpMask is for in/out typemaps that use temporal objects */
417 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
418 /* Simple returning values */
419 #define SWIG_BADOBJ (SWIG_ERROR)
420 #define SWIG_OLDOBJ (SWIG_OK)
421 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
422 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
423 /* Check, add and del mask methods */
424 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
425 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
426 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
427 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
428 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
429 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
430
431 /* Cast-Rank Mode */
432 #if defined(SWIG_CASTRANK_MODE)
433 # ifndef SWIG_TypeRank
434 # define SWIG_TypeRank unsigned long
435 # endif
436 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
437 # define SWIG_MAXCASTRANK (2)
438 # endif
439 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
440 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
441 SWIGINTERNINLINE int SWIG_AddCast(int r) {
442 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
443 }
444 SWIGINTERNINLINE int SWIG_CheckState(int r) {
445 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
446 }
447 #else /* no cast-rank mode */
448 # define SWIG_AddCast(r) (r)
449 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
450 #endif
451
452
453 #include <string.h>
454
455 #ifdef __cplusplus
456 extern "C" {
457 #endif
458
459 typedef void *(*swig_converter_func)(void *, int *);
460 typedef struct swig_type_info *(*swig_dycast_func)(void **);
461
462 /* Structure to store information on one type */
463 typedef struct swig_type_info {
464 const char *name; /* mangled name of this type */
465 const char *str; /* human readable name of this type */
466 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
467 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
468 void *clientdata; /* language specific type data */
469 int owndata; /* flag if the structure owns the clientdata */
470 } swig_type_info;
471
472 /* Structure to store a type and conversion function used for casting */
473 typedef struct swig_cast_info {
474 swig_type_info *type; /* pointer to type that is equivalent to this type */
475 swig_converter_func converter; /* function to cast the void pointers */
476 struct swig_cast_info *next; /* pointer to next cast in linked list */
477 struct swig_cast_info *prev; /* pointer to the previous cast */
478 } swig_cast_info;
479
480 /* Structure used to store module information
481 * Each module generates one structure like this, and the runtime collects
482 * all of these structures and stores them in a circularly linked list.*/
483 typedef struct swig_module_info {
484 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
485 size_t size; /* Number of types in this module */
486 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
487 swig_type_info **type_initial; /* Array of initially generated type structures */
488 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
489 void *clientdata; /* Language specific module data */
490 } swig_module_info;
491
492 /*
493 Compare two type names skipping the space characters, therefore
494 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
495
496 Return 0 when the two name types are equivalent, as in
497 strncmp, but skipping ' '.
498 */
499 SWIGRUNTIME int
500 SWIG_TypeNameComp(const char *f1, const char *l1,
501 const char *f2, const char *l2) {
502 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
503 while ((*f1 == ' ') && (f1 != l1)) ++f1;
504 while ((*f2 == ' ') && (f2 != l2)) ++f2;
505 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
506 }
507 return (int)((l1 - f1) - (l2 - f2));
508 }
509
510 /*
511 Check type equivalence in a name list like <name1>|<name2>|...
512 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
513 */
514 SWIGRUNTIME int
515 SWIG_TypeCmp(const char *nb, const char *tb) {
516 int equiv = 1;
517 const char* te = tb + strlen(tb);
518 const char* ne = nb;
519 while (equiv != 0 && *ne) {
520 for (nb = ne; *ne; ++ne) {
521 if (*ne == '|') break;
522 }
523 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
524 if (*ne) ++ne;
525 }
526 return equiv;
527 }
528
529 /*
530 Check type equivalence in a name list like <name1>|<name2>|...
531 Return 0 if not equal, 1 if equal
532 */
533 SWIGRUNTIME int
534 SWIG_TypeEquiv(const char *nb, const char *tb) {
535 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
536 }
537
538 /*
539 Check the typename
540 */
541 SWIGRUNTIME swig_cast_info *
542 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
543 if (ty) {
544 swig_cast_info *iter = ty->cast;
545 while (iter) {
546 if (strcmp(iter->type->name, c) == 0) {
547 if (iter == ty->cast)
548 return iter;
549 /* Move iter to the top of the linked list */
550 iter->prev->next = iter->next;
551 if (iter->next)
552 iter->next->prev = iter->prev;
553 iter->next = ty->cast;
554 iter->prev = 0;
555 if (ty->cast) ty->cast->prev = iter;
556 ty->cast = iter;
557 return iter;
558 }
559 iter = iter->next;
560 }
561 }
562 return 0;
563 }
564
565 /*
566 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
567 */
568 SWIGRUNTIME swig_cast_info *
569 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
570 if (ty) {
571 swig_cast_info *iter = ty->cast;
572 while (iter) {
573 if (iter->type == from) {
574 if (iter == ty->cast)
575 return iter;
576 /* Move iter to the top of the linked list */
577 iter->prev->next = iter->next;
578 if (iter->next)
579 iter->next->prev = iter->prev;
580 iter->next = ty->cast;
581 iter->prev = 0;
582 if (ty->cast) ty->cast->prev = iter;
583 ty->cast = iter;
584 return iter;
585 }
586 iter = iter->next;
587 }
588 }
589 return 0;
590 }
591
592 /*
593 Cast a pointer up an inheritance hierarchy
594 */
595 SWIGRUNTIMEINLINE void *
596 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
597 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
598 }
599
600 /*
601 Dynamic pointer casting. Down an inheritance hierarchy
602 */
603 SWIGRUNTIME swig_type_info *
604 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
605 swig_type_info *lastty = ty;
606 if (!ty || !ty->dcast) return ty;
607 while (ty && (ty->dcast)) {
608 ty = (*ty->dcast)(ptr);
609 if (ty) lastty = ty;
610 }
611 return lastty;
612 }
613
614 /*
615 Return the name associated with this type
616 */
617 SWIGRUNTIMEINLINE const char *
618 SWIG_TypeName(const swig_type_info *ty) {
619 return ty->name;
620 }
621
622 /*
623 Return the pretty name associated with this type,
624 that is an unmangled type name in a form presentable to the user.
625 */
626 SWIGRUNTIME const char *
627 SWIG_TypePrettyName(const swig_type_info *type) {
628 /* The "str" field contains the equivalent pretty names of the
629 type, separated by vertical-bar characters. We choose
630 to print the last name, as it is often (?) the most
631 specific. */
632 if (!type) return NULL;
633 if (type->str != NULL) {
634 const char *last_name = type->str;
635 const char *s;
636 for (s = type->str; *s; s++)
637 if (*s == '|') last_name = s+1;
638 return last_name;
639 }
640 else
641 return type->name;
642 }
643
644 /*
645 Set the clientdata field for a type
646 */
647 SWIGRUNTIME void
648 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
649 swig_cast_info *cast = ti->cast;
650 /* if (ti->clientdata == clientdata) return; */
651 ti->clientdata = clientdata;
652
653 while (cast) {
654 if (!cast->converter) {
655 swig_type_info *tc = cast->type;
656 if (!tc->clientdata) {
657 SWIG_TypeClientData(tc, clientdata);
658 }
659 }
660 cast = cast->next;
661 }
662 }
663 SWIGRUNTIME void
664 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
665 SWIG_TypeClientData(ti, clientdata);
666 ti->owndata = 1;
667 }
668
669 /*
670 Search for a swig_type_info structure only by mangled name
671 Search is a O(log #types)
672
673 We start searching at module start, and finish searching when start == end.
674 Note: if start == end at the beginning of the function, we go all the way around
675 the circular list.
676 */
677 SWIGRUNTIME swig_type_info *
678 SWIG_MangledTypeQueryModule(swig_module_info *start,
679 swig_module_info *end,
680 const char *name) {
681 swig_module_info *iter = start;
682 do {
683 if (iter->size) {
684 size_t l = 0;
685 size_t r = iter->size - 1;
686 do {
687 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
688 size_t i = (l + r) >> 1;
689 const char *iname = iter->types[i]->name;
690 if (iname) {
691 int compare = strcmp(name, iname);
692 if (compare == 0) {
693 return iter->types[i];
694 } else if (compare < 0) {
695 if (i) {
696 r = i - 1;
697 } else {
698 break;
699 }
700 } else if (compare > 0) {
701 l = i + 1;
702 }
703 } else {
704 break; /* should never happen */
705 }
706 } while (l <= r);
707 }
708 iter = iter->next;
709 } while (iter != end);
710 return 0;
711 }
712
713 /*
714 Search for a swig_type_info structure for either a mangled name or a human readable name.
715 It first searches the mangled names of the types, which is a O(log #types)
716 If a type is not found it then searches the human readable names, which is O(#types).
717
718 We start searching at module start, and finish searching when start == end.
719 Note: if start == end at the beginning of the function, we go all the way around
720 the circular list.
721 */
722 SWIGRUNTIME swig_type_info *
723 SWIG_TypeQueryModule(swig_module_info *start,
724 swig_module_info *end,
725 const char *name) {
726 /* STEP 1: Search the name field using binary search */
727 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
728 if (ret) {
729 return ret;
730 } else {
731 /* STEP 2: If the type hasn't been found, do a complete search
732 of the str field (the human readable name) */
733 swig_module_info *iter = start;
734 do {
735 size_t i = 0;
736 for (; i < iter->size; ++i) {
737 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
738 return iter->types[i];
739 }
740 iter = iter->next;
741 } while (iter != end);
742 }
743
744 /* neither found a match */
745 return 0;
746 }
747
748 /*
749 Pack binary data into a string
750 */
751 SWIGRUNTIME char *
752 SWIG_PackData(char *c, void *ptr, size_t sz) {
753 static const char hex[17] = "0123456789abcdef";
754 const unsigned char *u = (unsigned char *) ptr;
755 const unsigned char *eu = u + sz;
756 for (; u != eu; ++u) {
757 unsigned char uu = *u;
758 *(c++) = hex[(uu & 0xf0) >> 4];
759 *(c++) = hex[uu & 0xf];
760 }
761 return c;
762 }
763
764 /*
765 Unpack binary data from a string
766 */
767 SWIGRUNTIME const char *
768 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
769 unsigned char *u = (unsigned char *) ptr;
770 const unsigned char *eu = u + sz;
771 for (; u != eu; ++u) {
772 char d = *(c++);
773 unsigned char uu;
774 if ((d >= '0') && (d <= '9'))
775 uu = (unsigned char)((d - '0') << 4);
776 else if ((d >= 'a') && (d <= 'f'))
777 uu = (unsigned char)((d - ('a'-10)) << 4);
778 else
779 return (char *) 0;
780 d = *(c++);
781 if ((d >= '0') && (d <= '9'))
782 uu |= (unsigned char)(d - '0');
783 else if ((d >= 'a') && (d <= 'f'))
784 uu |= (unsigned char)(d - ('a'-10));
785 else
786 return (char *) 0;
787 *u = uu;
788 }
789 return c;
790 }
791
792 /*
793 Pack 'void *' into a string buffer.
794 */
795 SWIGRUNTIME char *
796 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
797 char *r = buff;
798 if ((2*sizeof(void *) + 2) > bsz) return 0;
799 *(r++) = '_';
800 r = SWIG_PackData(r,&ptr,sizeof(void *));
801 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
802 strcpy(r,name);
803 return buff;
804 }
805
806 SWIGRUNTIME const char *
807 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
808 if (*c != '_') {
809 if (strcmp(c,"NULL") == 0) {
810 *ptr = (void *) 0;
811 return name;
812 } else {
813 return 0;
814 }
815 }
816 return SWIG_UnpackData(++c,ptr,sizeof(void *));
817 }
818
819 SWIGRUNTIME char *
820 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
821 char *r = buff;
822 size_t lname = (name ? strlen(name) : 0);
823 if ((2*sz + 2 + lname) > bsz) return 0;
824 *(r++) = '_';
825 r = SWIG_PackData(r,ptr,sz);
826 if (lname) {
827 strncpy(r,name,lname+1);
828 } else {
829 *r = 0;
830 }
831 return buff;
832 }
833
834 SWIGRUNTIME const char *
835 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
836 if (*c != '_') {
837 if (strcmp(c,"NULL") == 0) {
838 memset(ptr,0,sz);
839 return name;
840 } else {
841 return 0;
842 }
843 }
844 return SWIG_UnpackData(++c,ptr,sz);
845 }
846
847 #ifdef __cplusplus
848 }
849 #endif
850
851 /* Errors in SWIG */
852 #define SWIG_UnknownError -1
853 #define SWIG_IOError -2
854 #define SWIG_RuntimeError -3
855 #define SWIG_IndexError -4
856 #define SWIG_TypeError -5
857 #define SWIG_DivisionByZero -6
858 #define SWIG_OverflowError -7
859 #define SWIG_SyntaxError -8
860 #define SWIG_ValueError -9
861 #define SWIG_SystemError -10
862 #define SWIG_AttributeError -11
863 #define SWIG_MemoryError -12
864 #define SWIG_NullReferenceError -13
865
866
867
868 #if !SWIG_OCTAVE_PREREQ(3,2,0)
869 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
870 #else
871 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
872 #endif
873
874 SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
875 if (num_args > max_args && !varargs)
876 error("function %s takes at most %i arguments", func_name, max_args);
877 else if (num_args < min_args)
878 error("function %s requires at least %i arguments", func_name, min_args);
879 else
880 return true;
881 return false;
882 }
883
884 SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
885 ovl->append(ov);
886 return ovl;
887 }
888
889 SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
890 switch (code) {
891 case SWIG_MemoryError:
892 return "SWIG_MemoryError";
893 case SWIG_IOError:
894 return "SWIG_IOError";
895 case SWIG_RuntimeError:
896 return "SWIG_RuntimeError";
897 case SWIG_IndexError:
898 return "SWIG_IndexError";
899 case SWIG_TypeError:
900 return "SWIG_TypeError";
901 case SWIG_DivisionByZero:
902 return "SWIG_DivisionByZero";
903 case SWIG_OverflowError:
904 return "SWIG_OverflowError";
905 case SWIG_SyntaxError:
906 return "SWIG_SyntaxError";
907 case SWIG_ValueError:
908 return "SWIG_ValueError";
909 case SWIG_SystemError:
910 return "SWIG_SystemError";
911 case SWIG_AttributeError:
912 return "SWIG_AttributeError";
913 }
914 return "SWIG unknown error";
915 }
916
917 SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
918 octave_value type(SWIG_ErrorType(code));
919 std::string r = msg;
920 r += " (" + type.string_value() + ")";
921 error(r.c_str());
922 return octave_value(r);
923 }
924
925 #define SWIG_fail goto fail
926
927 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
928 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
929 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
930 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
931 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
932 #define swig_owntype int
933
934 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
935 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
936
937 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
938 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
939
940 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
941 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
942
943 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
944 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
945 #define SWIG_MODULE_CLIENTDATA_TYPE void*
946
947 #define Octave_Error_Occurred() 0
948 #define SWIG_Octave_AddErrorMsg(msg) {;}
949
950 SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata);
951 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer);
952
953 // For backward compatibility only
954 #define SWIG_POINTER_EXCEPTION 0
955 #define SWIG_arg_fail(arg) 0
956
957 // Runtime API implementation
958
959 #include <map>
960 #include <vector>
961 #include <string>
962
963 typedef octave_value_list(*octave_func) (const octave_value_list &, int);
964 class octave_swig_type;
965
966 namespace Swig {
967
968 #ifdef SWIG_DIRECTORS
969
970 class Director;
971
972 typedef std::map < void *, Director * > rtdir_map;
973 SWIGINTERN rtdir_map* get_rtdir_map();
974 SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
975 SWIGINTERNINLINE void erase_rtdir(void *vptr);
976 SWIGINTERNINLINE Director *get_rtdir(void *vptr);
977
978 SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
979 SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
980 SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
981
982 #endif
983
984 SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
985 SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov);
986 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
987 }
988
989 #ifdef SWIG_DIRECTORS
990 SWIGRUNTIME void swig_acquire_ownership(void *vptr);
991 SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
992 SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
993 #endif
994
995 struct swig_octave_member {
996 const char *name;
997 octave_func method;
998 octave_func get_method;
999 octave_func set_method;
1000 int flags; // 1 static, 2 global
1001 const char *doc;
1002 bool is_static() const {
1003 return flags &1;
1004 } bool is_global() const {
1005 return flags &2;
1006 }
1007 };
1008
1009 struct swig_octave_class {
1010 const char *name;
1011 swig_type_info **type;
1012 int director;
1013 octave_func constructor;
1014 const char *constructor_doc;
1015 octave_func destructor;
1016 const swig_octave_member *members;
1017 const char **base_names;
1018 const swig_type_info **base;
1019 };
1020
1021 #if SWIG_OCTAVE_PREREQ(4,4,0)
1022 // in Octave 4.4 behaviour of octave_builtin() appears to have changed and 'self' argument is no longer passed
1023 // to function (maybe because this is now a 'method'??) so need to create our own octave_function subclass
1024 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(new octave_swig_bound_func(func, args))
1025 class octave_swig_bound_func : public octave_function {
1026 public:
1027
1028 octave_swig_bound_func(void) : octave_function(), method(0), first_args()
1029 { }
1030
1031 octave_swig_bound_func(octave_function* _method, octave_value_list _first_args)
1032 : octave_function("", ""), method(_method), first_args(_first_args)
1033 { }
1034
1035 octave_swig_bound_func(const octave_swig_bound_func& f) = delete;
1036
1037 octave_swig_bound_func& operator= (const octave_swig_bound_func& f) = delete;
1038
1039 ~octave_swig_bound_func(void) = default;
1040
1041 bool is_function(void) const { return true; }
1042
1043 octave_function* function_value(bool = false) { return this; }
1044
1045 octave_value_list call(octave::tree_evaluator& tw, int nargout = 0, const octave_value_list& args = octave_value_list()) {
1046 octave_value_list all_args;
1047 all_args.append(first_args);
1048 all_args.append(args);
1049 return method->call(tw, nargout, all_args);
1050 }
1051
1052 octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1053 octave_value_list ovl = subsref(ops, idx, 1);
1054 return ovl.length() ? ovl(0) : octave_value();
1055 }
1056
1057 octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1058 assert(ops.size() > 0);
1059 assert(ops.size() == idx.size());
1060 if (ops != "(")
1061 error("invalid function call");
1062 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1063 return call(tw, nargout, *idx.begin());
1064 }
1065
1066 protected:
1067
1068 octave_function* method;
1069 octave_value_list first_args;
1070
1071 std::set<std::string> dispatch_classes;
1072
1073 private:
1074
1075 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
1076 };
1077 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_bound_func, "octave_swig_bound_func", "octave_swig_bound_func");
1078 #else
1079 #define SWIG_OCTAVE_BOUND_FUNC(func, args) octave_value(func)
1080 #endif
1081
1082 // octave_swig_type plays the role of both the shadow class and the class
1083 // representation within Octave, since there is no support for classes.
1084 //
1085 // These should really be decoupled, with the class support added to Octave
1086 // and the shadow class given by an m-file script. That would dramatically
1087 // reduce the runtime complexity, and be more in line w/ other modules.
1088
1089 class octave_swig_type:public octave_base_value {
1090 struct cpp_ptr {
1091 void *ptr;
1092 bool destroyed;
1093 cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
1094 }};
1095 typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
1096
1097 mutable swig_module_info *module;
1098
1099 const swig_type_info *construct_type; // type of special type object
1100 std::vector < type_ptr_pair > types; // our c++ base classes
1101 int own; // whether we call c++ destructors when we die
1102
1103 typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
1104 typedef std::map < std::string, member_value_pair > member_map;
1105 member_map members;
1106 bool always_static;
1107
1108 const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
1109 if (!type->clientdata)
1110 return 0;
1111 swig_octave_class *c = (swig_octave_class *) type->clientdata;
1112 const swig_octave_member *m;
1113 for (m = c->members; m->name; ++m)
1114 if (m->name == name)
1115 return m;
1116 for (int j = 0; c->base_names[j]; ++j) {
1117 if (!c->base[j]) {
1118 if (!module)
1119 module = SWIG_GetModule(0);
1120 assert(module);
1121 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1122 }
1123 if (!c->base[j])
1124 return 0;
1125 if ((m = find_member(c->base[j], name)))
1126 return m;
1127 }
1128 return 0;
1129 }
1130
1131 member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
1132 member_map::iterator it = members.find(name);
1133 if (it != members.end())
1134 return &it->second;
1135 const swig_octave_member *m;
1136 for (unsigned int j = 0; j < types.size(); ++j)
1137 if ((m = find_member(types[j].first, name)))
1138 return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
1139 if (!insert_if_not_found)
1140 return 0;
1141 return &members[name];
1142 }
1143
1144 const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
1145 if (!base) {
1146 for (unsigned int j = 0; j < types.size(); ++j) {
1147 assert(types[j].first->clientdata);
1148 swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1149 if (cj->name == name)
1150 return types[j].first;
1151 }
1152 return 0;
1153 }
1154 assert(base->clientdata);
1155 swig_octave_class *c = (swig_octave_class *) base->clientdata;
1156 for (int j = 0; c->base_names[j]; ++j) {
1157 if (!c->base[j]) {
1158 if (!module)
1159 module = SWIG_GetModule(0);
1160 assert(module);
1161 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1162 }
1163 if (!c->base[j])
1164 return 0;
1165 assert(c->base[j]->clientdata);
1166 swig_octave_class *cj = (swig_octave_class *) c->base[j]->clientdata;
1167 if (cj->name == name)
1168 return c->base[j];
1169 }
1170 return 0;
1171 }
1172
1173 void load_members(const swig_octave_class* c,member_map& out) const {
1174 for (const swig_octave_member *m = c->members; m->name; ++m) {
1175 if (out.find(m->name) == out.end())
1176 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1177 }
1178 for (int j = 0; c->base_names[j]; ++j) {
1179 if (!c->base[j]) {
1180 if (!module)
1181 module = SWIG_GetModule(0);
1182 assert(module);
1183 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1184 }
1185 if (!c->base[j])
1186 continue;
1187 assert(c->base[j]->clientdata);
1188 const swig_octave_class *cj =
1189 (const swig_octave_class *) c->base[j]->clientdata;
1190 load_members(cj,out);
1191 }
1192 }
1193
1194 void load_members(member_map& out) const {
1195 out=members;
1196 for (unsigned int j = 0; j < types.size(); ++j)
1197 if (types[j].first->clientdata)
1198 load_members((const swig_octave_class *) types[j].first->clientdata, out);
1199 }
1200
1201 octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1202 if (m->second.is_defined())
1203 return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1204 else if (m->first && m->first->method)
1205 return m->first->method(args, nargout);
1206 error("member not defined or not invocable");
1207 return octave_value_list();
1208 }
1209
1210 bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const {
1211 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1212 member_value_pair *m = nc_this->find_member(symbol, false);
1213 if (!m || m->first->is_static() || m->first->is_global())
1214 return false;
1215 octave_value_list args;
1216 args.append(nc_this->as_value());
1217 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1218 if (argout.length() < 1)
1219 return false;
1220 ret = argout(0);
1221 return true;
1222 }
1223
1224 bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) const {
1225 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1226 member_value_pair *m = nc_this->find_member(symbol, false);
1227 if (!m || m->first->is_static() || m->first->is_global())
1228 return false;
1229 octave_value_list args;
1230 args.append(nc_this->as_value());
1231 args.append(make_value_hack(rhs));
1232 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1233 if (argout.length() < 1)
1234 return false;
1235 ret = argout(0);
1236 return true;
1237 }
1238
1239 bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) const {
1240 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1241 member_value_pair *m = nc_this->find_member(symbol, false);
1242 if (!m || m->first->is_static() || m->first->is_global())
1243 return false;
1244 octave_value_list args;
1245 args.append(nc_this->as_value());
1246 args.append(rhs);
1247 octave_value_list argout(nc_this->member_invoke(m, args, 1));
1248 if (argout.length() >= 1)
1249 ret = argout(0);
1250 return true;
1251 }
1252
1253 octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1254 if (m->second.is_defined()) {
1255 if (m->second.is_function() || m->second.is_function_handle()) {
1256 return SWIG_OCTAVE_BOUND_FUNC(m->second.function_value(), args);
1257 } else {
1258 return m->second;
1259 }
1260 } else if (m->first) {
1261 if (m->first->get_method)
1262 return m->first->get_method(args, 1);
1263 else if (m->first->method)
1264 return SWIG_OCTAVE_BOUND_FUNC(new octave_builtin(m->first->method), args);
1265 }
1266 error("undefined member");
1267 return octave_value_list();
1268 }
1269
1270 static octave_value make_value_hack(const octave_base_value &x) {
1271 ((octave_swig_type &) x).count++;
1272 return octave_value((octave_base_value *) &x);
1273 }
1274
1275 octave_swig_type(const octave_swig_type &x);
1276 octave_swig_type &operator=(const octave_swig_type &rhs);
1277 public:
1278
1279 octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1280 bool _always_static = false)
1281 : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1282 always_static(_always_static) {
1283 if (_type || _ptr)
1284 types.push_back(std::make_pair(_type, _ptr));
1285 #ifdef SWIG_DIRECTORS
1286 if (_ptr) {
1287 Swig::Director *d = Swig::get_rtdir(_ptr);
1288 if (d)
1289 Swig::swig_director_set_self(d, this);
1290 }
1291 #endif
1292 }
1293
1294 ~octave_swig_type() {
1295 if (own) {
1296 ++count;
1297 for (unsigned int j = 0; j < types.size(); ++j) {
1298 if (!types[j].first || !types[j].first->clientdata)
1299 continue;
1300 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1301 if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1302 c->destructor(as_value(), 0);
1303 }
1304 }
1305 }
1306 #ifdef SWIG_DIRECTORS
1307 for (unsigned int j = 0; j < types.size(); ++j)
1308 Swig::erase_rtdir(types[j].second.ptr);
1309 #endif
1310 }
1311
1312 dim_vector dims(void) const {
1313 octave_value out;
1314 if (!dispatch_unary_op("__dims__", out))
1315 return dim_vector(1,1);
1316
1317 // Return value should be cell or matrix of integers
1318 #if SWIG_OCTAVE_PREREQ(4,4,0)
1319 if (out.iscell()) {
1320 #else
1321 if (out.is_cell()) {
1322 #endif
1323 const Cell & c=out.cell_value();
1324 int ndim = c.rows();
1325 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1326
1327 dim_vector d;
1328 d.resize(ndim < 2 ? 2 : ndim);
1329 d(0) = d(1) = 1;
1330
1331 // Fill in dim_vector
1332 for (int k=0;k<ndim;k++) {
1333 const octave_value& obj = c(k);
1334 d.elem(k) = obj.int_value();
1335
1336 // __dims__ should return a cell filled with integers
1337 if (error_state) return dim_vector(1,1);
1338 }
1339 return d;
1340 #if SWIG_OCTAVE_PREREQ(4,4,0)
1341 } else if (out.is_matrix_type() || out.isnumeric() ) {
1342 #else
1343 } else if (out.is_matrix_type() || out.is_numeric_type() ) {
1344 #endif
1345 if (out.rows()==1 || out.columns()==1) {
1346 Array<int> a = out.int_vector_value();
1347 if (error_state) return dim_vector(1,1);
1348 dim_vector d;
1349 d.resize(a.numel() < 2 ? 2 : a.numel());
1350 d(0) = d(1) = 1;
1351 for (int k=0;k<a.numel();k++) {
1352 d.elem(k) = a(k);
1353 }
1354 return d;
1355 } else {
1356 return dim_vector(1,1);
1357 }
1358 } else {
1359 return dim_vector(1,1);
1360 }
1361 }
1362
1363 octave_value as_value() {
1364 ++count;
1365 return Swig::swig_value_ref(this);
1366 }
1367
1368 void incref() {
1369 ++count;
1370 }
1371
1372 void decref() {
1373 if (!--count)
1374 delete this;
1375 }
1376
1377 long swig_this() const {
1378 if (!types.size())
1379 return (long) this;
1380 return (long) types[0].second.ptr;
1381 }
1382 const char* help_text() const {
1383 if (!types.size())
1384 return 0;
1385 if (!types[0].first->clientdata)
1386 return 0;
1387 swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1388 return c->constructor_doc;
1389 }
1390
1391 std::string swig_type_name() const {
1392 // * need some way to manually name subclasses.
1393 // * eg optional first arg to subclass(), or named_subclass()
1394 std::string ret;
1395 for (unsigned int j = 0; j < types.size(); ++j) {
1396 if (j)
1397 ret += "_";
1398 if (types[j].first->clientdata) {
1399 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1400 ret += c->name;
1401 } else
1402 ret += types[j].first->name;
1403 }
1404 return ret;
1405 }
1406
1407 void merge(octave_swig_type &rhs) {
1408 rhs.own = 0;
1409 for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1410 assert(!rhs.types[j].second.destroyed);
1411 #ifdef SWIG_DIRECTORS
1412 Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1413 if (d)
1414 Swig::swig_director_set_self(d, this);
1415 #endif
1416 }
1417 types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1418 members.insert(rhs.members.begin(), rhs.members.end());
1419 #if SWIG_OCTAVE_PREREQ(4,4,0)
1420 assign(rhs.swig_type_name(), rhs.as_value());
1421 #else
1422 rhs.types.clear();
1423 rhs.members.clear();
1424 #endif
1425 }
1426
1427 typedef member_map::const_iterator swig_member_const_iterator;
1428 swig_member_const_iterator swig_members_begin() { return members.begin(); }
1429 swig_member_const_iterator swig_members_end() { return members.end(); }
1430
1431 int cast(void **vptr, swig_type_info *type, int *_own, int flags) {
1432 int res = SWIG_ERROR;
1433 if (_own)
1434 *_own = own;
1435 if (flags &SWIG_POINTER_DISOWN)
1436 own = 0;
1437 if (!type && types.size()) {
1438 if(vptr)
1439 *vptr = types[0].second.ptr;
1440 return SWIG_OK;
1441 }
1442 for (unsigned int j = 0; j < types.size(); ++j)
1443 if (type == types[j].first) {
1444 if(vptr)
1445 *vptr = types[j].second.ptr;
1446 return SWIG_OK;
1447 }
1448 for (unsigned int j = 0; j < types.size(); ++j) {
1449 swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1450 if (!tc)
1451 continue;
1452 if(vptr) {
1453 int newmemory = 0;
1454 *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1455 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1456 assert(_own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1457 if (_own)
1458 *_own = *_own | SWIG_CAST_NEW_MEMORY;
1459 }
1460 }
1461 res = SWIG_OK;
1462 break;
1463 }
1464 return res;
1465 }
1466
1467 bool is_owned() const {
1468 return own;
1469 }
1470
1471 #ifdef SWIG_DIRECTORS
1472 void director_destroyed(Swig::Director *d) {
1473 bool found = false;
1474 for (unsigned int j = 0; j < types.size(); ++j) {
1475 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1476 if (dj == d) {
1477 types[j].second.destroyed = true;
1478 found = true;
1479 }
1480 }
1481 assert(found);
1482 }
1483 #endif
1484
1485 void assign(const std::string &name, const octave_value &ov) {
1486 members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1487 }
1488
1489 void assign(const std::string &name, const swig_octave_member *m) {
1490 members[name] = std::make_pair(m, octave_value());
1491 }
1492
1493 octave_base_value *clone() const {
1494 // pass-by-value is probably not desired, and is harder;
1495 // requires calling copy constructors of contained types etc.
1496 assert(0);
1497 *(int *) 0 = 0;
1498 return 0;
1499 }
1500
1501 octave_base_value *empty_clone() const {
1502 return new octave_swig_type();
1503 }
1504
1505 bool is_defined() const {
1506 return true;
1507 }
1508
1509 virtual bool is_map() const {
1510 return true;
1511 }
1512
1513 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1514 octave_value_list ovl = subsref(ops, idx, 1);
1515 return ovl.length()? ovl(0) : octave_value();
1516 }
1517
1518 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1519 assert(ops.size() > 0);
1520 assert(ops.size() == idx.size());
1521
1522 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1523 int skip = 0;
1524 octave_value_list sub_ovl;
1525
1526 // constructor invocation
1527 if (ops[skip] == '(' && construct_type) {
1528 assert(construct_type->clientdata);
1529 swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
1530 if (!c->constructor) {
1531 error("cannot create instance");
1532 return octave_value_list();
1533 }
1534 octave_value_list args;
1535 if (c->director)
1536 args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1537 args.append(*idx_it++);
1538 ++skip;
1539 sub_ovl = c->constructor(args, nargout);
1540 }
1541 // member dereference or invocation
1542 else if (ops[skip] == '.') {
1543 std::string subname;
1544 const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1545 for (;;) {
1546 octave_value_list subname_ovl(*idx_it++);
1547 ++skip;
1548 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1549 subname = subname_ovl(0).string_value();
1550
1551 const swig_type_info *next_base = find_base(subname, base);
1552 if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1553 break;
1554 base = next_base;
1555 }
1556
1557 member_value_pair tmp, *m = &tmp;
1558 if (!base || !(m->first = find_member(base, subname)))
1559 m = find_member(subname, false);
1560 if (!m) {
1561 error("member not found");
1562 return octave_value_list();
1563 }
1564
1565 octave_value_list args;
1566 if (!always_static &&
1567 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1568 args.append(as_value());
1569 if (skip < (int) ops.size() && ops[skip] == '(' &&
1570 ((m->first && m->first->method) || m->second.is_function() ||
1571 m->second.is_function_handle())) {
1572 args.append(*idx_it++);
1573 ++skip;
1574 sub_ovl = member_invoke(m, args, nargout);
1575 } else {
1576 sub_ovl = member_deref(m, args);
1577 }
1578 }
1579 // index operator
1580 else {
1581 if (ops[skip] == '(' || ops[skip] == '{') {
1582 const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1583 octave_value_list args;
1584 args.append(*idx_it++);
1585 ++skip;
1586 if (!dispatch_index_op(op_name, args, sub_ovl)) {
1587 error("error evaluating index operator");
1588 return octave_value_list();
1589 }
1590 } else {
1591 error("unsupported subsref");
1592 return octave_value_list();
1593 }
1594 }
1595
1596 if (skip >= (int) ops.size())
1597 return sub_ovl;
1598 if (sub_ovl.length() < 1) {
1599 error("bad subs ref");
1600 return octave_value_list();
1601 }
1602 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1603 }
1604
1605 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1606 assert(ops.size() > 0);
1607 assert(ops.size() == idx.size());
1608
1609 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1610 int skip = 0;
1611
1612 if (ops.size() > 1) {
1613 std::list < octave_value_list >::const_iterator last = idx.end();
1614 --last;
1615 std::list < octave_value_list > next_idx(idx.begin(), last);
1616 octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1617 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1618 }
1619
1620 else if (ops[skip] == '(' || ops[skip] == '{') {
1621 const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1622 member_value_pair *m = find_member(op_name, false);
1623 if (m) {
1624 octave_value_list args;
1625 args.append(as_value());
1626 args.append(*idx_it);
1627 args.append(rhs);
1628 member_invoke(m, args, 1);
1629 } else
1630 error("%s member not found", op_name);
1631 }
1632
1633 else if (ops[skip] == '.') {
1634 octave_value_list subname_ovl(*idx_it++);
1635 ++skip;
1636 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1637 std::string subname = subname_ovl(0).string_value();
1638
1639 member_value_pair *m = find_member(subname, true);
1640 if (!m->first || !m->first->set_method) {
1641 m->first = 0;
1642 m->second = rhs;
1643 } else if (m->first->set_method) {
1644 octave_value_list args;
1645 if (!m->first->is_static() && !m->first->is_global())
1646 args.append(as_value());
1647 args.append(rhs);
1648 m->first->set_method(args, 1);
1649 } else
1650 error("member not assignable");
1651 } else
1652 error("unsupported subsasgn");
1653
1654 return as_value();
1655 }
1656
1657 virtual bool is_object() const {
1658 return true;
1659 }
1660
1661 virtual bool is_string() const {
1662 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1663 return !!nc_this->find_member("__str__", false);
1664 }
1665
1666 virtual std::string string_value(bool force = false) const {
1667 octave_value ret;
1668 if (!dispatch_unary_op("__str__", ret)) {
1669 error("__str__ method not defined");
1670 return std::string();
1671 }
1672 if (!ret.is_string()) {
1673 error("__str__ method did not return a string");
1674 return std::string();
1675 }
1676 return ret.string_value();
1677 }
1678
1679 virtual double scalar_value(bool frc_str_conv = false) const {
1680 octave_value ret;
1681 if (!dispatch_unary_op("__float__", ret)) {
1682 error("__float__ method not defined");
1683 }
1684 return ret.scalar_value();
1685 }
1686
1687 #if SWIG_OCTAVE_PREREQ(4,2,0)
1688 virtual octave_value as_double(void) const {
1689 octave_value ret;
1690 if (!dispatch_unary_op("__float__", ret)) {
1691 error("__float__ method not defined");
1692 }
1693 return ret.as_double();
1694 }
1695
1696 virtual octave_value as_single(void) const {
1697 octave_value ret;
1698 if (!dispatch_unary_op("__float__", ret)) {
1699 error("__float__ method not defined");
1700 }
1701 return ret.as_single();
1702 }
1703 #endif
1704
1705 #if SWIG_OCTAVE_PREREQ(3,8,0)
1706 virtual octave_value map(octave_base_value::unary_mapper_t umap) const {
1707 const std::string opname = std::string("__") + octave_base_value::get_umap_name(umap) + std::string("__");
1708 octave_value ret;
1709 if (!dispatch_unary_op(opname, ret)) {
1710 error((opname + std::string(" method not found")).c_str());
1711 return octave_value();
1712 }
1713 return ret;
1714 }
1715 #endif
1716
1717 #if SWIG_OCTAVE_PREREQ(3,3,52)
1718 virtual octave_map map_value() const {
1719 return octave_map();
1720 }
1721 #else
1722 virtual Octave_map map_value() const {
1723 return Octave_map();
1724 }
1725 #endif
1726
1727 virtual string_vector map_keys() const {
1728 member_map tmp;
1729 load_members(tmp);
1730
1731 string_vector keys(tmp.size());
1732 int k = 0;
1733 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1734 keys(k++) = it->first;
1735
1736 return keys;
1737 }
1738
1739 virtual bool save_ascii (std::ostream& os) {
1740 return true;
1741 }
1742
1743 virtual bool load_ascii (std::istream& is) {
1744 return true;
1745 }
1746
1747 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1748 return true;
1749 }
1750
1751 virtual bool load_binary (std::istream& is, bool swap,
1752 oct_mach_info::float_format fmt) {
1753 return true;
1754 }
1755
1756 #if defined (HAVE_HDF5)
1757 # if SWIG_OCTAVE_PREREQ(4,0,0)
1758 virtual bool
1759 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
1760 return true;
1761 }
1762
1763 virtual bool
1764 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
1765 return true;
1766 }
1767 # else
1768 virtual bool
1769 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1770 return true;
1771 }
1772
1773 virtual bool
1774 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1775 return true;
1776 }
1777 # endif
1778 #endif
1779
1780 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1781 return string_value();
1782 }
1783
1784 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1785 return string_value();
1786 }
1787
1788 static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1789 // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1790 // (rather than any module namespace).
1791
1792 octave_function *fcn = is_valid_function(symbol, std::string(), false);
1793 if (!fcn)
1794 return false;
1795 #if SWIG_OCTAVE_PREREQ(4,4,0)
1796 octave::tree_evaluator& tw = octave::interpreter::the_interpreter()->get_evaluator();
1797 octave_value_list retval = fcn->call(tw, 1, args);
1798 if (retval.length() == 1)
1799 ret = retval(0);
1800 #else
1801 ret = fcn->do_multi_index_op(1, args)(0);
1802 #endif
1803 return true;
1804 }
1805
1806 static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1807 octave_swig_type *ost = Swig::swig_value_deref(x);
1808 assert(ost);
1809
1810 octave_value ret;
1811 if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1812 return ret;
1813 std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1814 octave_value_list args;
1815 args.append(make_value_hack(x));
1816 if (dispatch_global_op(symbol, args, ret))
1817 return ret;
1818
1819 error("could not dispatch unary operator");
1820 return octave_value();
1821 }
1822
1823 static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1824 octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
1825 octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
1826
1827 octave_value ret;
1828 if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1829 return ret;
1830 if (rhs_ost) {
1831 if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1832 if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1833 return ret;
1834 if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1835 return ret;
1836 }
1837 if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1838 return ret;
1839 }
1840
1841 std::string symbol;
1842 octave_value_list args;
1843 args.append(make_value_hack(lhs));
1844 args.append(make_value_hack(rhs));
1845
1846 symbol = SWIG_op_prefix;
1847 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1848 symbol += "_";
1849 symbol += op_name;
1850 symbol += "_";
1851 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1852 if (dispatch_global_op(symbol, args, ret))
1853 return ret;
1854
1855 symbol = SWIG_op_prefix;
1856 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1857 symbol += "_";
1858 symbol += op_name;
1859 symbol += "_";
1860 symbol += "any";
1861 if (dispatch_global_op(symbol, args, ret))
1862 return ret;
1863
1864 symbol = SWIG_op_prefix;
1865 symbol += "any";
1866 symbol += "_";
1867 symbol += op_name;
1868 symbol += "_";
1869 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1870 if (dispatch_global_op(symbol, args, ret))
1871 return ret;
1872
1873 error("could not dispatch binary operator");
1874 return octave_value();
1875 }
1876
1877 #if SWIG_OCTAVE_PREREQ(4,0,0)
1878 void print(std::ostream &os, bool pr_as_read_syntax = false)
1879 #else
1880 void print(std::ostream &os, bool pr_as_read_syntax = false) const
1881 #endif
1882 {
1883 if (is_string()) {
1884 os << string_value();
1885 return;
1886 }
1887
1888 member_map tmp;
1889 load_members(tmp);
1890
1891 indent(os);
1892 os << "{"; newline(os);
1893 increment_indent_level();
1894 for (unsigned int j = 0; j < types.size(); ++j) {
1895 indent(os);
1896 if (types[j].first->clientdata) {
1897 const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1898 os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1899 } else {
1900 os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1901 }
1902 }
1903 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1904 indent(os);
1905 if (it->second.first) {
1906 const char *objtype = it->second.first->method ? "method" : "variable";
1907 const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1908 os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1909 assert(it->second.first->name == it->first);
1910 } else {
1911 os << it->first; newline(os);
1912 }
1913 }
1914 decrement_indent_level();
1915 indent(os);
1916 os << "}"; newline(os);
1917 }
1918 };
1919
1920 // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1921 // will call clone() via make_unique() if there is more than one outstanding
1922 // reference to the lhs, and forces the clone's reference count to 1
1923 // (so you can't just increment your own count and return this).
1924 //
1925 // One way to fix this (without modifying Octave) is to add a level of
1926 // indirection such that clone copies ref-counted pointer and we keep
1927 // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1928 //
1929 // Supporting both pass-by-{ref,value} and toggling via %feature/option
1930 // might be nice.
1931
1932 class octave_swig_ref:public octave_base_value {
1933 octave_swig_type *ptr;
1934 public:
1935 octave_swig_ref(octave_swig_type *_ptr = 0)
1936 :ptr(_ptr) { }
1937
1938 ~octave_swig_ref()
1939 { if (ptr) ptr->decref(); }
1940
1941 octave_swig_type *get_ptr() const
1942 { return ptr; }
1943
1944 octave_base_value *clone() const
1945 { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
1946
1947 octave_base_value *empty_clone() const
1948 { return new octave_swig_ref(0); }
1949
1950 dim_vector dims(void) const
1951 { return ptr->dims(); }
1952
1953 bool is_defined() const
1954 { return ptr->is_defined(); }
1955
1956 virtual bool is_map() const
1957 { return ptr->is_map(); }
1958
1959 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
1960 { return ptr->subsref(ops, idx); }
1961
1962 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
1963 { return ptr->subsref(ops, idx, nargout); }
1964
1965 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
1966 { return ptr->subsasgn(ops, idx, rhs); }
1967
1968 virtual bool is_object() const
1969 { return ptr->is_object(); }
1970
1971 virtual bool is_string() const
1972 { return ptr->is_string(); }
1973
1974 virtual std::string string_value(bool force = false) const
1975 { return ptr->string_value(force); }
1976
1977 virtual double scalar_value(bool frc_str_conv = false) const
1978 { return ptr->scalar_value(frc_str_conv); }
1979
1980 #if SWIG_OCTAVE_PREREQ(4,2,0)
1981 virtual octave_value as_double(void) const
1982 { return ptr->as_double(); }
1983
1984 virtual octave_value as_single(void) const
1985 { return ptr->as_single(); }
1986 #endif
1987
1988 #if SWIG_OCTAVE_PREREQ(3,8,0)
1989 virtual octave_value map(octave_base_value::unary_mapper_t umap) const
1990 { return ptr->map(umap); }
1991 #endif
1992
1993 #if SWIG_OCTAVE_PREREQ(3,3,52)
1994 virtual octave_map map_value() const
1995 { return ptr->map_value(); }
1996 #else
1997 virtual Octave_map map_value() const
1998 { return ptr->map_value(); }
1999 #endif
2000
2001 virtual string_vector map_keys() const
2002 { return ptr->map_keys(); }
2003
2004 virtual bool save_ascii (std::ostream& os)
2005 { return ptr->save_ascii(os); }
2006
2007 virtual bool load_ascii (std::istream& is)
2008 { return ptr->load_ascii(is); }
2009
2010 virtual bool save_binary (std::ostream& os, bool& save_as_floats)
2011 { return ptr->save_binary(os, save_as_floats); }
2012
2013 virtual bool load_binary (std::istream& is, bool swap,
2014 oct_mach_info::float_format fmt)
2015 { return ptr->load_binary(is, swap, fmt); }
2016
2017 #if defined (HAVE_HDF5)
2018 # if SWIG_OCTAVE_PREREQ(4,0,0)
2019 virtual bool
2020 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats)
2021 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2022
2023 virtual bool
2024 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug)
2025 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2026 # else
2027 virtual bool
2028 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
2029 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
2030
2031 virtual bool
2032 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
2033 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
2034 # endif
2035 #endif
2036
2037 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
2038 { return ptr->convert_to_str(pad, force, type); }
2039
2040 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
2041 { return ptr->convert_to_str_internal(pad, force, type); }
2042
2043 #if SWIG_OCTAVE_PREREQ(4,0,0)
2044 void print(std::ostream &os, bool pr_as_read_syntax = false)
2045 #else
2046 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2047 #endif
2048 { return ptr->print(os, pr_as_read_syntax); }
2049
2050 virtual type_conv_info numeric_conversion_function(void) const {
2051 return octave_base_value::type_conv_info (default_numeric_conversion_function,
2052 octave_scalar::static_type_id ());
2053 }
2054
2055 private:
2056 static octave_base_value *default_numeric_conversion_function (const octave_base_value& a) {
2057 const octave_swig_ref& v = dynamic_cast<const octave_swig_ref&>(a);
2058 return new octave_scalar(v.scalar_value());
2059 }
2060
2061 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2062 DECLARE_OCTAVE_ALLOCATOR;
2063 #endif
2064 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;
2065 };
2066 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2067 DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref);
2068 #endif
2069 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
2070
2071 class octave_swig_packed:public octave_base_value {
2072 swig_type_info *type;
2073 std::vector < char > buf;
2074 public:
2075
2076 octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
2077 : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
2078 }
2079
2080 bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
2081 if (outtype && outtype != type)
2082 return false;
2083 assert(sz <= buf.size());
2084 std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
2085 return true;
2086 }
2087
2088 octave_base_value *clone() const {
2089 return new octave_swig_packed(*this);
2090 }
2091
2092 octave_base_value *empty_clone() const {
2093 return new octave_swig_packed();
2094 }
2095
2096 bool is_defined() const {
2097 return true;
2098 }
2099
2100 #if SWIG_OCTAVE_PREREQ(4,0,0)
2101 void print(std::ostream &os, bool pr_as_read_syntax = false)
2102 #else
2103 void print(std::ostream &os, bool pr_as_read_syntax = false) const
2104 #endif
2105 {
2106 indent(os);
2107 os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
2108 }
2109
2110
2111 virtual bool save_ascii (std::ostream& os) {
2112 return true;
2113 }
2114
2115 virtual bool load_ascii (std::istream& is) {
2116 return true;
2117 }
2118
2119 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
2120 return true;
2121 }
2122
2123 virtual bool load_binary (std::istream& is, bool swap,
2124 oct_mach_info::float_format fmt) {
2125 return true;
2126 }
2127
2128 #if defined (HAVE_HDF5)
2129 # if SWIG_OCTAVE_PREREQ(4,0,0)
2130 virtual bool
2131 save_hdf5 (octave_hdf5_id loc_id, const char *name, bool save_as_floats) {
2132 return true;
2133 }
2134
2135 virtual bool
2136 load_hdf5 (octave_hdf5_id loc_id, const char *name, bool have_h5giterate_bug) {
2137 return true;
2138 }
2139 # else
2140 virtual bool
2141 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
2142 return true;
2143 }
2144
2145 virtual bool
2146 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
2147 return true;
2148 }
2149 # endif
2150 #endif
2151
2152 private:
2153 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2154 DECLARE_OCTAVE_ALLOCATOR;
2155 #endif
2156 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;
2157 };
2158 #if !SWIG_OCTAVE_PREREQ(4,0,0)
2159 DEFINE_OCTAVE_ALLOCATOR(octave_swig_packed);
2160 #endif
2161 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
2162
2163 SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
2164 error("attempt to set immutable member variable");
2165 return octave_value_list();
2166 }
2167
2168 struct octave_value_ref {
2169 const octave_value_list &ovl;
2170 int j;
2171
2172 octave_value_ref(const octave_value_list &_ovl, int _j)
2173 :ovl(_ovl), j(_j) { }
2174
2175 operator octave_value() const {
2176 return ovl(j);
2177 }
2178
2179 octave_value operator*() const {
2180 return ovl(j);
2181 }
2182 };
2183
2184
2185 namespace Swig {
2186
2187 SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
2188 return new octave_swig_ref(ost);
2189 }
2190
2191 SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov) {
2192 if (
2193 #if SWIG_OCTAVE_PREREQ(4,4,0)
2194 ov.iscell()
2195 #else
2196 ov.is_cell()
2197 #endif
2198 && ov.rows() == 1 && ov.columns() == 1)
2199 ov = ov.cell_value()(0);
2200 return swig_value_deref(*ov.internal_rep());
2201 }
2202
2203 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
2204 if (ov.type_id() != octave_swig_ref::static_type_id())
2205 return 0;
2206 const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
2207 return osr->get_ptr();
2208 }
2209
2210 }
2211
2212
2213 #define swig_unary_op(name) \
2214 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
2215 return octave_swig_type::dispatch_unary_op(x,#name); \
2216 }
2217 #define swig_binary_op(name) \
2218 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
2219 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
2220 }
2221 #if SWIG_OCTAVE_PREREQ(4,4,0)
2222 #define swigreg_unary_op(name) \
2223 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2224 typeinfo.register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2225 #else
2226 #define swigreg_unary_op(name) \
2227 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
2228 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
2229 #endif
2230 #if SWIG_OCTAVE_PREREQ(4,4,0)
2231 #define swigreg_binary_op(name) \
2232 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2233 typeinfo.register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2234 #else
2235 #define swigreg_binary_op(name) \
2236 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
2237 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
2238 #endif
2239
2240 swig_unary_op(not);
2241 swig_unary_op(uplus);
2242 swig_unary_op(uminus);
2243 swig_unary_op(transpose);
2244 swig_unary_op(hermitian);
2245 swig_unary_op(incr);
2246 swig_unary_op(decr);
2247
2248 swig_binary_op(add);
2249 swig_binary_op(sub);
2250 swig_binary_op(mul);
2251 swig_binary_op(div);
2252 swig_binary_op(pow);
2253 swig_binary_op(ldiv);
2254 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2255 swig_binary_op(lshift);
2256 swig_binary_op(rshift);
2257 #endif
2258 swig_binary_op(lt);
2259 swig_binary_op(le);
2260 swig_binary_op(eq);
2261 swig_binary_op(ge);
2262 swig_binary_op(gt);
2263 swig_binary_op(ne);
2264 swig_binary_op(el_mul);
2265 swig_binary_op(el_div);
2266 swig_binary_op(el_pow);
2267 swig_binary_op(el_ldiv);
2268 swig_binary_op(el_and);
2269 swig_binary_op(el_or);
2270
2271 SWIGRUNTIME void SWIG_InstallUnaryOps(int tid) {
2272 #if SWIG_OCTAVE_PREREQ(4,4,0)
2273 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2274 #endif
2275 swigreg_unary_op(not);
2276 swigreg_unary_op(uplus);
2277 swigreg_unary_op(uminus);
2278 swigreg_unary_op(transpose);
2279 swigreg_unary_op(hermitian);
2280 swigreg_unary_op(incr);
2281 swigreg_unary_op(decr);
2282 }
2283 SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
2284 #if SWIG_OCTAVE_PREREQ(4,4,0)
2285 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
2286 #endif
2287 swigreg_binary_op(add);
2288 swigreg_binary_op(sub);
2289 swigreg_binary_op(mul);
2290 swigreg_binary_op(div);
2291 swigreg_binary_op(pow);
2292 swigreg_binary_op(ldiv);
2293 #if !SWIG_OCTAVE_PREREQ(4,2,0)
2294 swigreg_binary_op(lshift);
2295 swigreg_binary_op(rshift);
2296 #endif
2297 swigreg_binary_op(lt);
2298 swigreg_binary_op(le);
2299 swigreg_binary_op(eq);
2300 swigreg_binary_op(ge);
2301 swigreg_binary_op(gt);
2302 swigreg_binary_op(ne);
2303 swigreg_binary_op(el_mul);
2304 swigreg_binary_op(el_div);
2305 swigreg_binary_op(el_pow);
2306 swigreg_binary_op(el_ldiv);
2307 swigreg_binary_op(el_and);
2308 swigreg_binary_op(el_or);
2309 }
2310 SWIGRUNTIME void SWIG_InstallOps(int tid) {
2311 // here we assume that tid are conseq integers increasing from zero, and
2312 // that our tid is the last one. might be better to have explicit string
2313 // list of types we should bind to, and use lookup_type to resolve their tid.
2314
2315 SWIG_InstallUnaryOps(tid);
2316 SWIG_InstallBinaryOps(tid, tid);
2317 for (int j = 0; j < tid; ++j) {
2318 SWIG_InstallBinaryOps(j, tid);
2319 SWIG_InstallBinaryOps(tid, j);
2320 }
2321 }
2322
2323 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2324 int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2325
2326 #ifdef SWIG_DIRECTORS
2327 Swig::Director *d = Swig::get_rtdir(ptr);
2328 if (d && Swig::swig_director_get_self(d))
2329 return Swig::swig_director_get_self(d)->as_value();
2330 #endif
2331 return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2332 }
2333
2334 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2335 if (
2336 #if SWIG_OCTAVE_PREREQ(4,4,0)
2337 ov.iscell()
2338 #else
2339 ov.is_cell()
2340 #endif
2341 && ov.rows() == 1 && ov.columns() == 1)
2342 ov = ov.cell_value()(0);
2343 if (!ov.is_defined() ||
2344 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2345 if (ptr)
2346 *ptr = 0;
2347 return SWIG_OK;
2348 }
2349 if (ov.type_id() != octave_swig_ref::static_type_id())
2350 return SWIG_ERROR;
2351 octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2352 octave_swig_type *ost = osr->get_ptr();
2353 return ost->cast(ptr, type, own, flags);
2354 }
2355
2356 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2357 return new octave_swig_packed(type, (char *) ptr, sz);
2358 }
2359
2360 SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2361 if (!ov.is_defined())
2362 return SWIG_ERROR;
2363 if (ov.type_id() != octave_swig_packed::static_type_id())
2364 return SWIG_ERROR;
2365 octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2366 return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2367 }
2368
2369 SWIGRUNTIMEINLINE void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2370 module_ns->assign(name, ov);
2371 }
2372
2373 SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name) {
2374 #if SWIG_OCTAVE_PREREQ(4,4,0)
2375 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2376 return symtab.global_varval(name);
2377 #else
2378 return get_global_value(name, true);
2379 #endif
2380 }
2381
2382 SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2383 #if SWIG_OCTAVE_PREREQ(4,4,0)
2384 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2385 symtab.global_assign(name, value);
2386 #else
2387 set_global_value(name, value);
2388 #endif
2389 }
2390
2391 SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name) {
2392 #if SWIG_OCTAVE_PREREQ(4,4,0)
2393 octave::symbol_table& symtab = octave::interpreter::the_interpreter()->get_symbol_table();
2394 octave::symbol_scope symscope = octave::interpreter::the_interpreter()->get_current_scope();
2395 symscope.assign(name, symtab.global_varval(name));
2396 symscope.mark_global(name);
2397 #else
2398 #if !SWIG_OCTAVE_PREREQ(3,2,0)
2399 link_to_global_variable(curr_sym_tab->lookup(name, true));
2400 #else
2401 #if !SWIG_OCTAVE_PREREQ(3,8,0)
2402 symbol_table::varref(name);
2403 #endif
2404 symbol_table::mark_global(name);
2405 #endif
2406 #endif
2407 }
2408
2409 SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata) {
2410 octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2411 if (!ov.is_defined() ||
2412 ov.type_id() != octave_swig_packed::static_type_id())
2413 return 0;
2414 const octave_swig_packed* osp =
2415 static_cast < const octave_swig_packed *> (ov.internal_rep());
2416 swig_module_info *pointer = 0;
2417 osp->copy(0, &pointer, sizeof(swig_module_info *));
2418 return pointer;
2419 }
2420
2421 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2422 octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2423 SWIG_Octave_SetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION, ov);
2424 }
2425
2426
2427
2428 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2429
2430 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2431
2432
2433
2434 /* -------- TYPES TABLE (BEGIN) -------- */
2435
2436 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2437 #define SWIGTYPE_p_char swig_types[1]
2438 #define SWIGTYPE_p_double swig_types[2]
2439 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2440 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2441 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2442 #define SWIGTYPE_p_int swig_types[6]
2443 #define SWIGTYPE_p_p_char swig_types[7]
2444 #define SWIGTYPE_p_unsigned_int swig_types[8]
2445 static swig_type_info *swig_types[10];
2446 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2447 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2448 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2449
2450 /* -------- TYPES TABLE (END) -------- */
2451
2452
2453 #define SWIGVERSION 0x030012
2454 #define SWIG_VERSION SWIGVERSION
2455
2456
2457 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2458 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2459
2460
2461 #include <stdexcept>
2462
2463
2464 // #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2465 #undef PACKAGE
2466 #undef VERSION
2467
2468 #include "plplotP.h"
2469
2470 // Temporary fix for problems with -fvisibility=hidden and octave headers.
2471 #ifdef OCTAVE_EXPORT
2472 #if defined ( __GNUC__ ) && __GNUC__ > 3
2473 #undef OCTAVE_EXPORT
2474 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2475 #endif
2476 #endif
2477
2478
2479
2480 // I hate global variables but this is the best way I can think of
2481 // to manage consistency checking among function arguments.
2482 static PLINT Alen = 0;
2483 static PLINT Xlen = 0, Ylen = 0;
2484
2485
2486 // Convenience functions copied from matwrap-based approach (currently
2487 // stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2488 // tricky scalar case and also adopted so that the resulting
2489 // swig-generated source code will look similar to the matwrap-generated
2490 // source code.
2491
2492 inline int max( int a, int b )
2493 {
2494 return a >= b ? a : b;
2495 }
2496 inline int min( int a, int b )
2497 {
2498 return a >= b ? a : b;
2499 }
2500
2501 //
2502 // Function to get the total length (rows*columns) of an octave object of
2503 // arbitrary type.
2504 // Arguments:
2505 // 1) The octave object.
2506 //
2507 // If the object is a scalar, the array length is 1.
2508 //
2509 static int
2510 _arraylen( const octave_value &o_obj )
2511 {
2512 return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2513 // max is necessary because sometimes
2514 // rows() or columns() return -1 or 0 for
2515 // scalars.
2516 }
2517
2518 //
2519 // Function to get the number of dimensions of an object.
2520 //
2521 static int
2522 _n_dims( const octave_value &o_obj )
2523 {
2524 if ( max( o_obj.columns(), 1 ) > 1 )
2525 return 2;
2526 // max is necessary because sometimes
2527 // rows() or columns() return -1 or 0 for
2528 // scalars.
2529 else if ( max( o_obj.rows(), 1 ) > 1 )
2530 return 1;
2531 else
2532 return 0;
2533 }
2534
2535 //
2536 // Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2537 //
2538 static inline int
2539 _dim( const octave_value &o_obj, int dim_idx )
2540 {
2541 if ( dim_idx == 0 )
2542 return max( o_obj.rows(), 0 );
2543 // max is necessary because sometimes
2544 // rows() or columns() return -1 or 0 for
2545 // scalars.
2546 else if ( dim_idx == 1 )
2547 return max( o_obj.columns(), 0 );
2548 else
2549 return 1;
2550 }
2551
2552 //
2553 // The following function converts an array of doubles into some other
2554 // numeric type. Arguments:
2555 // 1) Where to store the result. The type is determined from the type of
2556 // this pointer.
2557 // 2) A vector of doubles to convert.
2558 // 3) The number of doubles.
2559 //
2560 template <class FLOAT>
2561 static inline void
2562 _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2563 {
2564 while ( n_el-- > 0 )
2565 *out_arr++ = (FLOAT) ( *in_arr++ );
2566 }
2567
2568 template void _cvt_double_to( int *, double *, unsigned );
2569 template void _cvt_double_to( unsigned *, double *, unsigned );
2570 template void _cvt_double_to( long *, double *, unsigned );
2571 template void _cvt_double_to( unsigned long *, double *, unsigned );
2572 template void _cvt_double_to( short *, double *, unsigned );
2573 template void _cvt_double_to( unsigned short *, double *, unsigned );
2574 template void _cvt_double_to( float *, double *, unsigned );
2575 // Instantiate our templates. Octave uses
2576 // manual template instantiation.
2577
2578 //
2579 // Convert an array of some other type into an array of doubles. Arguments:
2580 // 1) The array of objects of other type.
2581 // 2) The output array of doubles.
2582 // 3) The number of elements to convert.
2583 //
2584 template <class FLOAT>
2585 static inline void
2586 _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2587 {
2588 while ( n_el-- > 0 )
2589 *d_arr++ = double(*arr++);
2590 }
2591
2592 template void _cvt_to_double( int *, double *, unsigned );
2593 template void _cvt_to_double( unsigned *, double *, unsigned );
2594 template void _cvt_to_double( long *, double *, unsigned );
2595 template void _cvt_to_double( unsigned long *, double *, unsigned );
2596 template void _cvt_to_double( short *, double *, unsigned );
2597 template void _cvt_to_double( unsigned short *, double *, unsigned );
2598 template void _cvt_to_double( float *, double *, unsigned );
2599 // Instantiate our templates. Octave uses
2600 // manual template instantiation.
2601
2602
2603 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2604 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2605 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2606 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2607 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2608 typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer );
2609 typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2610
2611
2612 #include <iostream>
2613
2614 octave_function *fcnMapForm;
2615 std::string nameMapForm;
2616
2617 void mapform_octave( PLINT n, PLFLT *x, PLFLT *y )
2618 {
2619 octave_idx_type i;
2620 octave_value_list functionArguments;
2621 octave_value_list retval;
2622
2623 Matrix xin( n, 1 );
2624 Matrix yin( n, 1 );
2625 Matrix xout;
2626 Matrix yout;
2627
2628 for ( i = 0; i < n; i++ )
2629 {
2630 xin( i, 0 ) = x[i];
2631 yin( i, 0 ) = y[i];
2632 }
2633
2634 functionArguments( 0 ) = xin;
2635 functionArguments( 1 ) = yin;
2636
2637 if ( fcnMapForm != NULL )
2638 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2639 retval = octave::feval( fcnMapForm, functionArguments, 1 );
2640 #else
2641 retval = feval( fcnMapForm, functionArguments, 1 );
2642 #endif
2643 else
2644 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2645 retval = octave::feval( nameMapForm, functionArguments, 1 );
2646 #else
2647 retval = feval( nameMapForm, functionArguments, 1 );
2648 #endif
2649
2650 if ( retval.length() >= 2 )
2651 {
2652 xout = retval( 0 ).matrix_value();
2653 yout = retval( 1 ).matrix_value();
2654
2655 for ( i = 0; i < n; i++ )
2656 {
2657 x[i] = xout( i, 0 );
2658 y[i] = yout( i, 0 );
2659 }
2660 }
2661 }
2662
2663
2664 octave_function *fcnLabelFunc;
2665 std::string nameLabelFunc;
2666
2667 void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2668 {
2669 int i;
2670 octave_value_list functionArguments;
2671 octave_value_list retval;
2672
2673 Matrix inAxis( 1, 1 );
2674 Matrix inValue( 1, 1 );
2675 inAxis( 0, 0 ) = axis;
2676 inValue( 0, 0 ) = value;
2677
2678 functionArguments( 0 ) = inAxis;
2679 functionArguments( 1 ) = inValue;
2680
2681 if ( fcnLabelFunc != NULL )
2682 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2683 retval = octave::feval( fcnLabelFunc, functionArguments, 1 );
2684 #else
2685 retval = feval( fcnLabelFunc, functionArguments, 1 );
2686 #endif
2687 else
2688 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2689 retval = octave::feval( nameLabelFunc, functionArguments, 1 );
2690 #else
2691 retval = feval( nameLabelFunc, functionArguments, 1 );
2692 #endif
2693
2694 strncpy( label, retval( 0 ).string_value().c_str(), length );
2695 }
2696
2697
2698 octave_function *fcnCoordTrans;
2699 std::string nameCoordTrans;
2700
2701 void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2702 {
2703 octave_idx_type i;
2704 octave_value_list functionArguments;
2705 octave_value_list retval;
2706
2707 Matrix xin( 1, 1 );
2708 Matrix yin( 1, 1 );
2709 Matrix xout;
2710 Matrix yout;
2711
2712 xin( 0, 0 ) = x;
2713 yin( 0, 0 ) = y;
2714
2715 functionArguments( 0 ) = xin;
2716 functionArguments( 1 ) = yin;
2717
2718 if ( fcnCoordTrans != NULL )
2719 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2720 retval = octave::feval( fcnCoordTrans, functionArguments, 1 );
2721 #else
2722 retval = feval( fcnCoordTrans, functionArguments, 1 );
2723 #endif
2724 else
2725 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
2726 retval = octave::feval( nameCoordTrans, functionArguments, 1 );
2727 #else
2728 retval = feval( nameCoordTrans, functionArguments, 1 );
2729 #endif
2730
2731 if ( retval.length() >= 2 )
2732 {
2733 xout = retval( 0 ).matrix_value();
2734 yout = retval( 1 ).matrix_value();
2735
2736 *xt = xout( 0, 0 );
2737 *yt = yout( 0, 0 );
2738 }
2739 }
2740
2741
2742 void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2743 {
2744 PLINT i;
2745 printf( "nlegend =%d\n", nlegend );
2746 for ( i = 0; i < nlegend; i++ )
2747 {
2748 printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2749 printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2750 printf( "text[%d] =%s\n", i, text[i] );
2751 }
2752 }
2753
2754
2755 #include <limits.h>
2756 #if !defined(SWIG_NO_LLONG_MAX)
2757 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2758 # define LLONG_MAX __LONG_LONG_MAX__
2759 # define LLONG_MIN (-LLONG_MAX - 1LL)
2760 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2761 # endif
2762 #endif
2763
2764
2765 SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2766 {
2767 if (!ov.is_scalar_type())
2768 return SWIG_TypeError;
2769 if (ov.is_complex_scalar())
2770 return SWIG_TypeError;
2771 if (ov.is_double_type()||ov.is_single_type()) {
2772 double v=ov.double_value();
2773 if (v!=floor(v))
2774 return SWIG_TypeError;
2775 }
2776 if (val)
2777 *val = ov.long_value();
2778 return SWIG_OK;
2779 }
2780
2781
2782 SWIGINTERN int
2783 SWIG_AsVal_int (octave_value obj, int *val)
2784 {
2785 long v;
2786 int res = SWIG_AsVal_long (obj, &v);
2787 if (SWIG_IsOK(res)) {
2788 if ((v < INT_MIN || v > INT_MAX)) {
2789 return SWIG_OverflowError;
2790 } else {
2791 if (val) *val = static_cast< int >(v);
2792 }
2793 }
2794 return res;
2795 }
2796
2797
2798 static int my_plGetCursor( int *state, int *keysym, int *button, char *string, int *pX, int *pY, PLFLT *dX, PLFLT *dY, PLFLT *wX, PLFLT *wY, int *subwin )
2799 {
2800 PLGraphicsIn gin;
2801 int status; status = plGetCursor( &gin );
2802 *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2803 strncpy( string, gin.string, PL_MAXKEY - 1 );
2804 string[PL_MAXKEY - 1] = '\0';
2805
2806 *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2807 return status;
2808 }
2809
2810
2811 SWIGINTERN int
2812 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2813 {
2814 if (
2815 #if SWIG_OCTAVE_PREREQ(4,4,0)
2816 ov.iscell()
2817 #else
2818 ov.is_cell()
2819 #endif
2820 && ov.rows() == 1 && ov.columns() == 1)
2821 ov = ov.cell_value()(0);
2822 if (!ov.is_string())
2823 return SWIG_TypeError;
2824
2825 std::string str=ov.string_value();
2826 size_t len=str.size();
2827 char* cstr=(char*)str.c_str();
2828 if (alloc) {
2829 *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
2830 *alloc = SWIG_NEWOBJ;
2831 } else if (cptr)
2832 *cptr = cstr;
2833 if (psize)
2834 *psize = len + 1;
2835 return SWIG_OK;
2836 }
2837
2838
2839
2840
2841
2842 SWIGINTERNINLINE octave_value SWIG_From_long (long value)
2843 {
2844 return octave_value(value);
2845 }
2846
2847
2848 SWIGINTERNINLINE octave_value
2849 SWIG_From_int (int value)
2850 {
2851 return SWIG_From_long (value);
2852 }
2853
2854
2855 SWIGINTERNINLINE octave_value SWIG_From_double (double value)
2856 {
2857 return octave_value(value);
2858 }
2859
2860
2861 // Translates relative device coordinates to world coordinates.
2862 static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2863 {
2864 PLGraphicsIn gin;
2865 int st;
2866 gin.dX = x_in; gin.dY = y_in;
2867 st = plTranslateCursor( &gin );
2868 *x = gin.wX; *y = gin.wY;
2869 return st;
2870 }
2871
2872
2873 SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2874 {
2875 if (!ov.is_scalar_type())
2876 return SWIG_TypeError;
2877 if (ov.is_complex_scalar())
2878 return SWIG_TypeError;
2879 if (val)
2880 *val = ov.double_value();
2881 return SWIG_OK;
2882 }
2883
2884
2885 // Create 1d stripchart
2886
2887 void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
2888 PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2889 PLFLT xlpos, PLFLT ylpos,
2890 PLBOOL y_ascl, PLBOOL acc,
2891 PLINT colbox, PLINT collab,
2892 const PLINT *colline, const PLINT *styline,
2893 const char *legline1, const char *legline2, const char *legline3, const char *legline4,
2894 const char *labx, const char *laby, const char *labtop )
2895 {
2896 const char *legline[4];
2897 legline[0] = legline1; legline[1] = legline2;
2898 legline[2] = legline3; legline[3] = legline4;
2899 c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2900 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2901 labx, laby, labtop );
2902 }
2903
2904
2905 // One more hack. As it is not possible (and would not be desirable) to pass
2906 // an Octave function to plcont(), I have defined three plcont():
2907 // plcont uses a defined here xform()
2908 // plcont0 uses pltr0()
2909 // plcont1 uses pltr1()
2910 // plcont2 uses pltr2()
2911 // plcont2p uses pltr2p()
2912 //
2913 // Also, as plplot expect vectorized bidimensional arrays, I provided a
2914 // f2c, which is a #define that does the necessary conversion.
2915 //
2916
2917 void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
2918 {
2919 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2920 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2921 }
2922
2923 // convert from Fortran like arrays (one vector), to C like 2D arrays
2924
2925 #define f2c( f, ff, nx, ny ) \
2926 PLFLT * *ff; \
2927 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2928 for ( int i = 0; i < nx; i++ ) { \
2929 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2930 for ( int j = 0; j < ny; j++ ) \
2931 *( ff[i] + j ) = *( f + nx * j + i );}
2932
2933 // simpler plcont() for use with xform()
2934
2935 void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2936 PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2937 {
2938 f2c( f, ff, nx, ny );
2939 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
2940 }
2941
2942 // plcont() for use with pltr0() NOT TESTED
2943
2944 void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2945 PLINT ly, const PLFLT *clevel, PLINT nlevel )
2946 {
2947 f2c( f, ff, nx, ny );
2948 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
2949 }
2950
2951 // plcont() for use with pltr1()
2952
2953 void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2954 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2955 {
2956 PLcGrid grid1;
2957 grid1.nx = nx; grid1.ny = ny;
2958 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2959 f2c( f, ff, nx, ny );
2960 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
2961 }
2962
2963 // plcont() for use with pltr2()
2964 void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2965 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2966 {
2967 PLcGrid2 grid2;
2968 f2c( xg, xgg, nx, ny );
2969 f2c( yg, ygg, nx, ny );
2970 grid2.nx = nx; grid2.ny = ny;
2971 grid2.xg = xgg; grid2.yg = ygg;
2972 f2c( f, ff, nx, ny );
2973 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2974 }
2975
2976 // plcont() for use with pltr2p()
2977
2978 void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2979 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2980 {
2981 PLcGrid2 grid2;
2982 f2c( xg, xgg, nx, ny );
2983 f2c( yg, ygg, nx, ny );
2984 grid2.nx = nx; grid2.ny = ny;
2985 grid2.xg = xgg; grid2.yg = ygg;
2986 f2c( f, ff, nx, ny );
2987 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2988 }
2989
2990
2991 void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
2992 const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
2993 PLFLT *zg, int type, PLFLT data )
2994 {
2995 f2c( zg, zgg, nptsx, nptsy );
2996 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2997 for ( int i = 0; i < nptsx; i++ )
2998 for ( int j = 0; j < nptsy; j++ )
2999 *( zg + nptsx * j + i ) = zgg[i][j];
3000 }
3001
3002
3003 // Plots a mesh representation of the function z[x][y].
3004
3005 void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
3006 {
3007 f2c( z, zz, nx, ny );
3008 c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
3009 }
3010
3011 // Plots a mesh representation of the function z[x][y] with contour
3012
3013 void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3014 {
3015 f2c( z, zz, nx, ny );
3016 c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3017 }
3018
3019
3020 // Plots a 3-d representation of the function z[x][y].
3021 void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3022 PLINT nx, PLINT ny, PLINT opt, PLINT side )
3023 {
3024 f2c( z, zz, nx, ny );
3025 c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
3026 }
3027
3028 // Plots a 3-d representation of the function z[x][y] with contour
3029 void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3030 PLINT nx, PLINT ny, PLINT opt,
3031 const PLFLT *clevel, PLINT nlevel )
3032 {
3033 f2c( z, zz, nx, ny );
3034 c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3035 }
3036 // Plots a 3-d representation of the function z[x][y] with contour with y
3037 // index limits
3038 void my_plot3dcl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3039 PLINT nx, PLINT ny, PLINT opt,
3040 const PLFLT * clevel, PLINT nlevel,
3041 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3042 {
3043 f2c( z, zz, nx, ny );
3044 c_plot3dcl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3045 indexxmin, indexxmax, indexymin, indexymax );
3046 }
3047
3048
3049 void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
3050 PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
3051 {
3052 f2c( z, zz, nx, ny );
3053 c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
3054 }
3055
3056 void my_plsurf3dl( const PLFLT * x, const PLFLT * y, const PLFLT * z,
3057 PLINT nx, PLINT ny, PLINT opt, const PLFLT * clevel, PLINT nlevel,
3058 PLINT indexxmin, PLINT indexxmax, const PLINT * indexymin, const PLINT * indexymax )
3059 {
3060 f2c( z, zz, nx, ny );
3061 c_plsurf3dl( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel,
3062 indexxmin, indexxmax, indexymin, indexymax );
3063 }
3064
3065
3066 // The same as in plcont. I have hardcoded the first function pointer
3067 // to plfill(). The second function pointer will use the same convention
3068 // as in plcont().
3069 //
3070
3071 // the simpler plshade()
3072 void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
3073 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3074 PLFLT shade_min, PLFLT shade_max,
3075 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3076 PLINT min_color, PLINT min_width,
3077 PLINT max_color, PLINT max_width,
3078 PLINT rectangular, PLFLT *tr )
3079 {
3080 f2c( a, aa, nx, ny );
3081 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3082 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3083 min_color, min_width, max_color, max_width,
3084 plfill, rectangular, xform, tr );
3085 }
3086
3087 // plshade() for use with pltr1
3088 void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3089 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3090 PLFLT shade_min, PLFLT shade_max,
3091 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3092 PLINT min_color, PLINT min_width,
3093 PLINT max_color, PLINT max_width,
3094 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3095 {
3096 PLcGrid grid1;
3097 grid1.nx = nx; grid1.ny = ny;
3098 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3099 f2c( a, aa, nx, ny );
3100 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3101 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3102 min_color, min_width, max_color, max_width,
3103 plfill, rectangular, pltr1, &grid1 );
3104 }
3105
3106 // plshade() for use with pltr2
3107 void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
3108 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3109 PLFLT shade_min, PLFLT shade_max,
3110 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
3111 PLINT min_color, PLINT min_width,
3112 PLINT max_color, PLINT max_width,
3113 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3114 {
3115 PLcGrid2 grid2;
3116 f2c( xg, xgg, nx, ny );
3117 f2c( yg, ygg, nx, ny );
3118 grid2.nx = nx; grid2.ny = ny;
3119 grid2.xg = xgg; grid2.yg = ygg;
3120 f2c( a, aa, nx, ny );
3121 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3122 shade_min, shade_max, sh_cmap, sh_color, sh_width,
3123 min_color, min_width, max_color, max_width,
3124 plfill, rectangular, pltr2, &grid2 );
3125 }
3126
3127
3128
3129 void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
3130 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3131 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3132 PLINT cont_color, PLINT cont_width,
3133 PLINT rectangular )
3134 {
3135 f2c( a, aa, nx, ny );
3136 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3137 clevel, nlevel, fill_width, cont_color, cont_width,
3138 plfill, rectangular, NULL, NULL );
3139 }
3140
3141 void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
3142 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3143 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3144 PLINT cont_color, PLINT cont_width,
3145 PLINT rectangular, PLFLT *tr )
3146 {
3147 f2c( a, aa, nx, ny );
3148 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3149 clevel, nlevel, fill_width, cont_color, cont_width,
3150 plfill, rectangular, xform, tr );
3151 }
3152
3153 void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
3154 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3155 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3156 PLINT cont_color, PLINT cont_width,
3157 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3158 {
3159 PLcGrid grid1;
3160 grid1.nx = nx; grid1.ny = ny;
3161 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3162
3163 f2c( a, aa, nx, ny );
3164 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3165 clevel, nlevel, fill_width, cont_color, cont_width,
3166 plfill, rectangular, pltr1, &grid1 );
3167 }
3168
3169 void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
3170 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
3171 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
3172 PLINT cont_color, PLINT cont_width,
3173 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
3174 {
3175 PLcGrid2 grid2;
3176 f2c( xg, xgg, nx, ny );
3177 f2c( yg, ygg, nx, ny );
3178 grid2.nx = nx; grid2.ny = ny;
3179 grid2.xg = xgg; grid2.yg = ygg;
3180 f2c( a, aa, nx, ny );
3181 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
3182 clevel, nlevel, fill_width, cont_color, cont_width,
3183 plfill, rectangular, pltr2, &grid2 );
3184 }
3185
3186
3187 // Plot an array of vector arrows - uses the same function pointer
3188 // convention as plcont
3189
3190 void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
3191 {
3192 f2c( u, uu, nx, ny );
3193 f2c( v, vv, nx, ny );
3194 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
3195 }
3196
3197 // plvect() for use with pltr1
3198 void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3199 {
3200 PLcGrid grid1;
3201 grid1.nx = nx; grid1.ny = ny;
3202 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3203 f2c( u, uu, nx, ny );
3204 f2c( v, vv, nx, ny );
3205 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
3206 }
3207
3208 // plvect() for use with pltr2
3209 void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
3210 {
3211 PLcGrid2 grid2;
3212 f2c( xg, xgg, nx, ny );
3213 f2c( yg, ygg, nx, ny );
3214 grid2.nx = nx; grid2.ny = ny;
3215 grid2.xg = xgg; grid2.yg = ygg;
3216 f2c( u, uu, nx, ny );
3217 f2c( v, vv, nx, ny );
3218 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
3219 }
3220
3221
3222 // Plot an image with distortion - uses the same function pointer
3223 void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
3224 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3225 PLFLT zmin, PLFLT zmax,
3226 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
3227 {
3228 f2c( a, aa, nx, ny );
3229 plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
3230 }
3231
3232 // Plot an image with distortion - uses the same function pointer
3233 // convention as plcont
3234 void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
3235 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3236 PLFLT zmin, PLFLT zmax,
3237 PLFLT valuemin, PLFLT valuemax )
3238 {
3239 f2c( a, aa, nx, ny );
3240 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
3241 }
3242
3243 void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
3244 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3245 PLFLT zmin, PLFLT zmax,
3246 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
3247 {
3248 f2c( a, aa, nx, ny );
3249 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
3250 }
3251
3252 // plimagefr() for use with pltr1
3253 void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
3254 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3255 PLFLT zmin, PLFLT zmax,
3256 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3257 {
3258 PLcGrid grid1;
3259 grid1.nx = nx + 1; grid1.ny = ny + 1;
3260 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
3261 f2c( a, aa, nx, ny );
3262 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
3263 }
3264
3265 // plimagefr() for use with pltr2
3266 void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
3267 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
3268 PLFLT zmin, PLFLT zmax,
3269 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
3270 {
3271 PLcGrid2 grid2;
3272 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) );
3273 f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
3274 grid2.nx = nx + 1; grid2.ny = ny + 1;
3275 grid2.xg = xgg; grid2.yg = ygg;
3276 f2c( a, aa, nx, ny );
3277 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
3278 }
3279
3280
3281
3282 void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
3283 PLINT opt, PLINT position, PLFLT x, PLFLT y,
3284 PLFLT x_length, PLFLT y_length,
3285 PLINT bg_color, PLINT bb_color, PLINT bb_style,
3286 PLFLT low_cap_color, PLFLT high_cap_color,
3287 PLINT cont_color, PLFLT cont_width,
3288 PLINT n_labels, const PLINT *label_opts, const char **label,
3289 PLINT n_axes, const char ** axis_opts,
3290 const PLFLT *ticks, const PLINT *sub_ticks,
3291 const PLINT *n_values, const PLFLT *a )
3292 {
3293 PLINT nx, ny, i;
3294 nx = n_axes;
3295 ny = -1;
3296 for ( i = 0; i < nx; i++ )
3297 if ( n_values[i] > ny )
3298 ny = n_values[i];
3299 f2c( a, aa, nx, ny );
3300 c_plcolorbar( p_colorbar_width, p_colorbar_height,
3301 opt, position, x, y,
3302 x_length, y_length,
3303 bg_color, bb_color, bb_style,
3304 low_cap_color, high_cap_color,
3305 cont_color, cont_width,
3306 n_labels, label_opts, label,
3307 n_axes, axis_opts,
3308 ticks, sub_ticks,
3309 n_values, aa );
3310 }
3311
3312
3313
3314 SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
3315 {
3316 if (!ov.is_scalar_type())
3317 return SWIG_TypeError;
3318 if (ov.is_complex_scalar())
3319 return SWIG_TypeError;
3320 if (ov.is_double_type()||ov.is_single_type()) {
3321 double v=ov.double_value();
3322 if (v<0)
3323 return SWIG_OverflowError;
3324 if (v!=floor(v))
3325 return SWIG_TypeError;
3326 }
3327 if (ov.is_int8_type()||ov.is_int16_type()||
3328 ov.is_int32_type()) {
3329 long v=ov.long_value();
3330 if (v<0)
3331 return SWIG_OverflowError;
3332 }
3333 if (ov.is_int64_type()) {
3334 long long v=ov.int64_scalar_value().value();
3335 if (v<0)
3336 return SWIG_OverflowError;
3337 }
3338 if (val)
3339 *val = ov.ulong_value();
3340 return SWIG_OK;
3341 }
3342
3343
3344 SWIGINTERN int
3345 SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
3346 {
3347 unsigned long v;
3348 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3349 if (SWIG_IsOK(res)) {
3350 if ((v > UINT_MAX)) {
3351 return SWIG_OverflowError;
3352 } else {
3353 if (val) *val = static_cast< unsigned int >(v);
3354 }
3355 }
3356 return res;
3357 }
3358
3359
3360 SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long (unsigned long value)
3361 {
3362 return octave_value(value);
3363 }
3364
3365
3366 SWIGINTERNINLINE octave_value
3367 SWIG_From_unsigned_SS_int (unsigned int value)
3368 {
3369 return SWIG_From_unsigned_SS_long (value);
3370 }
3371
3372
3373 SWIGINTERN int
3374 SWIG_AsCharArray(octave_value obj, char *val, size_t size)
3375 {
3376 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3377 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3378 if (SWIG_IsOK(res)) {
3379 /* special case of single char conversion when we don't need space for NUL */
3380 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3381 if (csize <= size) {
3382 if (val) {
3383 if (csize) memcpy(val, cptr, csize*sizeof(char));
3384 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3385 }
3386 if (alloc == SWIG_NEWOBJ) {
3387 delete[] cptr;
3388 res = SWIG_DelNewMask(res);
3389 }
3390 return res;
3391 }
3392 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3393 }
3394 return SWIG_TypeError;
3395 }
3396
3397
3398 SWIGINTERN swig_type_info*
3399 SWIG_pchar_descriptor(void)
3400 {
3401 static int init = 0;
3402 static swig_type_info* info = 0;
3403 if (!init) {
3404 info = SWIG_TypeQuery("_p_char");
3405 init = 1;
3406 }
3407 return info;
3408 }
3409
3410
3411 SWIGINTERNINLINE octave_value
3412 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3413 {
3414 return std::string(carray,carray+size);
3415 }
3416
3417
3418 SWIGINTERN size_t
3419 SWIG_strnlen(const char* s, size_t maxlen)
3420 {
3421 const char *p;
3422 for (p = s; maxlen-- && *p; p++)
3423 ;
3424 return p - s;
3425 }
3426
3427
3428 SWIGINTERN int
3429 SWIG_AsVal_char (octave_value obj, char *val)
3430 {
3431 int res = SWIG_AsCharArray(obj, val, 1);
3432 if (!SWIG_IsOK(res)) {
3433 long v;
3434 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3435 if (SWIG_IsOK(res)) {
3436 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3437 if (val) *val = static_cast< char >(v);
3438 } else {
3439 res = SWIG_OverflowError;
3440 }
3441 }
3442 }
3443 return res;
3444 }
3445
3446 static const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3447 Specify viewport in absolute coordinates\n\
3448 \n\
3449 DESCRIPTION:\n\
3450 \n\
3451 Alternate routine to plvpor for setting up the viewport. This routine\n\
3452 should be used only if the viewport is required to have a definite\n\
3453 size in millimeters. The routine plgspa is useful for finding out the\n\
3454 size of the current subpage.\n\
3455 \n\
3456 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3457 \n\
3458 This function is used in example 10.\n\
3459 \n\
3460 \n\
3461 \n\
3462 SYNOPSIS:\n\
3463 \n\
3464 plsvpa(xmin, xmax, ymin, ymax)\n\
3465 \n\
3466 ARGUMENTS:\n\
3467 \n\
3468 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3469 viewport from the left-hand edge of the subpage in millimeters.\n\
3470 \n\
3471 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3472 viewport from the left-hand edge of the subpage in millimeters.\n\
3473 \n\
3474 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3475 viewport from the bottom edge of the subpage in millimeters.\n\
3476 \n\
3477 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3478 from the bottom edge of the subpage in millimeters.\n\
3479 ";
3480 static const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3481 Write text relative to viewport boundaries in 3D plots\n\
3482 \n\
3483 DESCRIPTION:\n\
3484 \n\
3485 Writes text at a specified position relative to the viewport\n\
3486 boundaries. Text may be written inside or outside the viewport, but\n\
3487 is clipped at the subpage boundaries. The reference point of a string\n\
3488 lies along a line passing through the string at half the height of a\n\
3489 capital letter. The position of the reference point along this line\n\
3490 is determined by just, and the position of the reference point\n\
3491 relative to the viewport is set by disp and pos.\n\
3492 \n\
3493 Redacted form: plmtex3(side, disp, pos, just, text)\n\
3494 \n\
3495 This function is used in example 28.\n\
3496 \n\
3497 \n\
3498 \n\
3499 SYNOPSIS:\n\
3500 \n\
3501 plmtex3(side, disp, pos, just, text)\n\
3502 \n\
3503 ARGUMENTS:\n\
3504 \n\
3505 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
3506 the side of the viewport along which the text is to be written.\n\
3507 The string should contain one or more of the following characters:\n\
3508 [xyz][ps][v]. Only one label is drawn at a time, i.e. xyp will\n\
3509 only label the X axis, not both the X and Y axes. x: Label the X\n\
3510 axis.\n\
3511 y: Label the Y axis.\n\
3512 z: Label the Z axis.\n\
3513 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3514 For X it is the axis that starts at y-min. For Y it is the\n\
3515 axis that starts at x-min.\n\
3516 s: Label the secondary axis.\n\
3517 v: Draw the text perpendicular to the axis.\n\
3518 \n\
3519 \n\
3520 disp (PLFLT, input) : Position of the reference point of string,\n\
3521 measured outwards from the specified viewport edge in units of the\n\
3522 current character height. Use negative disp to write within the\n\
3523 viewport.\n\
3524 \n\
3525 pos (PLFLT, input) : Position of the reference point of string\n\
3526 along the specified edge, expressed as a fraction of the length of\n\
3527 the edge.\n\
3528 \n\
3529 just (PLFLT, input) : Specifies the position of the string relative\n\
3530 to its reference point. If just=0. , the reference point is at\n\
3531 the left and if just=1. , it is at the right of the string. Other\n\
3532 values of just give intermediate justifications.\n\
3533 \n\
3534 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
3535 written out.\n\
3536 ";
3537 static const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3538 Set semitransparent cmap1 RGBA colors.\n\
3539 \n\
3540 DESCRIPTION:\n\
3541 \n\
3542 Set semitransparent cmap1 colors (see the PLplot documentation) using\n\
3543 RGBA vector values. This function also sets the number of cmap1\n\
3544 colors. N.B. Continuous cmap1 colors are indexed with a\n\
3545 floating-point index in the range from 0.0-1.0 which is linearly\n\
3546 transformed (e.g., by plcol1) to an integer index of these RGBA\n\
3547 vectors in the range from 0 to\n\
3548 ncol1-1. So in order for this continuous color model to work\n\
3549 properly, it is the responsibility of the user of plscmap1 to insure\n\
3550 that these RGBA vectors are continuous functions of their integer\n\
3551 indices.\n\
3552 \n\
3553 Redacted form: plscmap1a(r, g, b, alpha)\n\
3554 \n\
3555 This function is used in example 31.\n\
3556 \n\
3557 \n\
3558 \n\
3559 SYNOPSIS:\n\
3560 \n\
3561 plscmap1a(r, g, b, alpha, ncol1)\n\
3562 \n\
3563 ARGUMENTS:\n\
3564 \n\
3565 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3566 8-bit integers in the range from 0-255) the degree of red in the\n\
3567 color as a continuous function of the integer index of the vector.\n\
3568 \n\
3569 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3570 8-bit integers in the range from 0-255) the degree of green in the\n\
3571 color as a continuous function of the integer index of the vector.\n\
3572 \n\
3573 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
3574 8-bit integers in the range from 0-255) the degree of blue in the\n\
3575 color as a continuous function of the integer index of the vector.\n\
3576 \n\
3577 alpha (PLFLT_VECTOR, input) : A vector that represents (using PLFLT\n\
3578 values in the range from 0.0-1.0 where 0.0 corresponds to\n\
3579 completely transparent and 1.0 corresponds to completely opaque)\n\
3580 the alpha transparency of the color as a continuous function of\n\
3581 the integer index of the vector.\n\
3582 \n\
3583 ncol1 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
3584 vectors.\n\
3585 ";
3586 static const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3587 Select standard viewport\n\
3588 \n\
3589 DESCRIPTION:\n\
3590 \n\
3591 Selects the largest viewport within the subpage that leaves a standard\n\
3592 margin (left-hand margin of eight character heights, and a margin\n\
3593 around the other three sides of five character heights).\n\
3594 \n\
3595 Redacted form: plvsta()\n\
3596 \n\
3597 This function is used in examples 1, 12, 14, 17, 25, and 29.\n\
3598 \n\
3599 \n\
3600 \n\
3601 SYNOPSIS:\n\
3602 \n\
3603 plvsta()\n\
3604 ";
3605 static const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3606 Switch to graphics screen\n\
3607 \n\
3608 DESCRIPTION:\n\
3609 \n\
3610 Sets an interactive device to graphics mode, used in conjunction with\n\
3611 pltext to allow graphics and text to be interspersed. On a device\n\
3612 which supports separate text and graphics windows, this command causes\n\
3613 control to be switched to the graphics window. If already in graphics\n\
3614 mode, this command is ignored. It is also ignored on devices which\n\
3615 only support a single window or use a different method for shifting\n\
3616 focus. See also pltext.\n\
3617 \n\
3618 Redacted form: plgra()\n\
3619 \n\
3620 This function is used in example 1.\n\
3621 \n\
3622 \n\
3623 \n\
3624 SYNOPSIS:\n\
3625 \n\
3626 plgra()\n\
3627 ";
3628 static const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3629 Set 8-bit RGB values and PLFLT alpha transparency value for given cmap0 color index\n\
3630 \n\
3631 DESCRIPTION:\n\
3632 \n\
3633 Set 8-bit RGB value and PLFLT alpha transparency value for given cmap0\n\
3634 (see the PLplot documentation) index. Overwrites the previous color\n\
3635 value for the given index and, thus, does not result in any additional\n\
3636 allocation of space for colors.\n\
3637 \n\
3638 This function is used in example 30.\n\
3639 \n\
3640 \n\
3641 \n\
3642 SYNOPSIS:\n\
3643 \n\
3644 plscol0a(icol0, r, g, b, alpha)\n\
3645 \n\
3646 ARGUMENTS:\n\
3647 \n\
3648 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3649 number of colors (which is set by default, by plscmap0n, or even\n\
3650 by plscmap0).\n\
3651 \n\
3652 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3653 degree of red in the color.\n\
3654 \n\
3655 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3656 degree of green in the color.\n\
3657 \n\
3658 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3659 degree of blue in the color.\n\
3660 \n\
3661 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
3662 (0.0-1.0).\n\
3663 ";
3664 static const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3665 Set y axis parameters\n\
3666 \n\
3667 DESCRIPTION:\n\
3668 \n\
3669 Identical to plsxax, except that arguments are flags for y axis. See\n\
3670 the description of plsxax for more detail.\n\
3671 \n\
3672 Redacted form: plsyax(digmax, digits)\n\
3673 \n\
3674 This function is used in examples 1, 14, and 31.\n\
3675 \n\
3676 \n\
3677 \n\
3678 SYNOPSIS:\n\
3679 \n\
3680 plsyax(digmax, digits)\n\
3681 \n\
3682 ARGUMENTS:\n\
3683 \n\
3684 digmax (PLINT, input) : Variable to set the maximum number of\n\
3685 digits for the y axis. If nonzero, the printed label will be\n\
3686 switched to a floating-point representation when the number of\n\
3687 digits exceeds digmax.\n\
3688 \n\
3689 digits (PLINT, input) : Field digits value. Currently, changing\n\
3690 its value here has no effect since it is set only by plbox or\n\
3691 plbox3. However, the user may obtain its value after a call to\n\
3692 either of these functions by calling plgyax.\n\
3693 ";
3694 static const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3695 Returns 8-bit RGB values for given color index from cmap0\n\
3696 \n\
3697 DESCRIPTION:\n\
3698 \n\
3699 Returns 8-bit RGB values (0-255) for given color from cmap0 (see the\n\
3700 PLplot documentation). Values are negative if an invalid color id is\n\
3701 given.\n\
3702 \n\
3703 Redacted form: plgcol0(icol0, r, g, b)\n\
3704 \n\
3705 This function is used in example 2.\n\
3706 \n\
3707 \n\
3708 \n\
3709 SYNOPSIS:\n\
3710 \n\
3711 plgcol0(icol0, r, g, b)\n\
3712 \n\
3713 ARGUMENTS:\n\
3714 \n\
3715 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
3716 \n\
3717 r (PLINT_NC_SCALAR, output) : Returned value of the 8-bit red\n\
3718 value.\n\
3719 \n\
3720 g (PLINT_NC_SCALAR, output) : Returned value of the 8-bit green\n\
3721 value.\n\
3722 \n\
3723 b (PLINT_NC_SCALAR, output) : Returned value of the 8-bit blue\n\
3724 value.\n\
3725 ";
3726 static const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3727 Set seed for internal random number generator.\n\
3728 \n\
3729 DESCRIPTION:\n\
3730 \n\
3731 Set the seed for the internal random number generator. See plrandd for\n\
3732 further details.\n\
3733 \n\
3734 Redacted form: plseed(seed)\n\
3735 \n\
3736 This function is used in example 21.\n\
3737 \n\
3738 \n\
3739 \n\
3740 SYNOPSIS:\n\
3741 \n\
3742 plseed(seed)\n\
3743 \n\
3744 ARGUMENTS:\n\
3745 \n\
3746 seed (unsigned int, input) : Seed for random number generator.\n\
3747 ";
3748 static const char* _wrap_plot3dcl_texinfo = "-*- texinfo -*-\n\
3749 Magnitude colored plot surface with contour for z[x][y] with y index limits\n\
3750 \n\
3751 DESCRIPTION:\n\
3752 \n\
3753 When the implementation is completed this variant of plot3dc (see that\n\
3754 function\'s documentation for more details) should be suitable for the\n\
3755 case where the area of the x, y coordinate grid where z is defined can\n\
3756 be non-rectangular. The implementation is incomplete so the last 4\n\
3757 parameters of plot3dcl; indexxmin, indexxmax, indexymin, and\n\
3758 indexymax; are currently ignored and the functionality is otherwise\n\
3759 identical to that of plot3dc.\n\
3760 \n\
3761 Redacted form: General: plot3dcl(x, y, z, opt, clevel, indexxmin,\n\
3762 indexymin, indexymax)\n\
3763 \n\
3764 \n\
3765 This function is not used in any example.\n\
3766 \n\
3767 \n\
3768 \n\
3769 SYNOPSIS:\n\
3770 \n\
3771 plot3dcl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
3772 \n\
3773 ARGUMENTS:\n\
3774 \n\
3775 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
3776 which the function is evaluated.\n\
3777 \n\
3778 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
3779 which the function is evaluated.\n\
3780 \n\
3781 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
3782 plot. Should have dimensions of\n\
3783 nx by\n\
3784 ny.\n\
3785 \n\
3786 nx (PLINT, input) : Number of x values at which the function is\n\
3787 evaluated.\n\
3788 \n\
3789 ny (PLINT, input) : Number of y values at which the function is\n\
3790 evaluated.\n\
3791 \n\
3792 opt (PLINT, input) : Determines the way in which the surface is\n\
3793 represented. To specify more than one option just add the options,\n\
3794 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
3795 showing z as a function of x for each value of y[j] .\n\
3796 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
3797 for each value of x[i] .\n\
3798 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
3799 at which function is defined.\n\
3800 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
3801 the z value being plotted. The color is used from the current\n\
3802 cmap1.\n\
3803 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
3804 using parameters\n\
3805 nlevel and\n\
3806 clevel.\n\
3807 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
3808 the borders of the plotted function.\n\
3809 \n\
3810 \n\
3811 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
3812 levels.\n\
3813 \n\
3814 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
3815 \n\
3816 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
3817 corresponds to the first x index where z is defined.\n\
3818 \n\
3819 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
3820 which corresponds (by convention) to one more than the last x\n\
3821 index value where z is defined.\n\
3822 \n\
3823 indexymin (PLINT_VECTOR, input) : A vector containing y index\n\
3824 values which all must be ≥ 0. These values are the first y index\n\
3825 where z is defined for a particular x index in the range from\n\
3826 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
3827 indexxmax.\n\
3828 \n\
3829 indexymax (PLINT_VECTOR, input) : A vector containing y index\n\
3830 values which all must be ≤ ny. These values correspond (by\n\
3831 convention) to one more than the last y index where z is defined\n\
3832 for a particular x index in the range from indexxmin to indexxmax\n\
3833 - 1. The dimension of indexymax is indexxmax.\n\
3834 ";
3835 static const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3836 Get output file name\n\
3837 \n\
3838 DESCRIPTION:\n\
3839 \n\
3840 Gets the current output file name, if applicable.\n\
3841 \n\
3842 Redacted form: plgfnam(fnam)\n\
3843 \n\
3844 This function is used in example 31.\n\
3845 \n\
3846 \n\
3847 \n\
3848 SYNOPSIS:\n\
3849 \n\
3850 plgfnam(fnam)\n\
3851 \n\
3852 ARGUMENTS:\n\
3853 \n\
3854 fnam (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
3855 (with preallocated length of 80 characters or more) containing the\n\
3856 file name.\n\
3857 ";
3858 static const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3859 Specify window\n\
3860 \n\
3861 DESCRIPTION:\n\
3862 \n\
3863 Specify the window, i.e., the world coordinates of the edges of the\n\
3864 viewport.\n\
3865 \n\
3866 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3867 \n\
3868 This function is used in examples 1, 2, 4, 6-12, 14-16, 18, 21, 23-27,\n\
3869 29, and 31.\n\
3870 \n\
3871 \n\
3872 \n\
3873 SYNOPSIS:\n\
3874 \n\
3875 plwind(xmin, xmax, ymin, ymax)\n\
3876 \n\
3877 ARGUMENTS:\n\
3878 \n\
3879 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3880 of the viewport.\n\
3881 \n\
3882 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3883 of the viewport.\n\
3884 \n\
3885 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3886 the viewport.\n\
3887 \n\
3888 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3889 viewport.\n\
3890 ";
3891 static const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
3892 Set cmap1 colors using a piece-wise linear relationship\n\
3893 \n\
3894 DESCRIPTION:\n\
3895 \n\
3896 Set cmap1 colors using a piece-wise linear relationship between the\n\
3897 cmap1 intensity index (0.0-1.0) and position in HLS or RGB color space\n\
3898 (see the PLplot documentation). May be called at any time.\n\
3899 \n\
3900 The idea here is to specify a number of control points that define the\n\
3901 mapping between input cmap1 intensity indices and HLS or RGB. Between\n\
3902 these points, linear interpolation is used which gives a smooth\n\
3903 variation of color with intensity index. Any number of control points\n\
3904 may be specified, located at arbitrary positions, although typically 2\n\
3905 - 4 are enough. Another way of stating this is that we are traversing\n\
3906 a given number of lines through HLS or RGB space as we move through\n\
3907 cmap1 intensity indices. The control points at the minimum and\n\
3908 maximum position (0 and 1) must always be specified. By adding more\n\
3909 control points you can get more variation. One good technique for\n\
3910 plotting functions that vary about some expected average is to use an\n\
3911 additional 2 control points in the center (position ~= 0.5) that are\n\
3912 the same lightness as the background (typically white for paper\n\
3913 output, black for crt), and same hue as the boundary control points.\n\
3914 This allows the highs and lows to be very easily distinguished.\n\
3915 \n\
3916 Each control point must specify the cmap1 intensity index and the\n\
3917 associated three coordinates in HLS or RGB space. The first point\n\
3918 must correspond to position = 0, and the last to position = 1.\n\
3919 \n\
3920 If RGB colors are provided then the interpolation takes place in RGB\n\
3921 space and is trivial. However if HLS colors are provided then, because\n\
3922 of the circular nature of the color wheel for the hue coordinate, the\n\
3923 interpolation could be performed in either direction around the color\n\
3924 wheel. The default behaviour is for the hue to be linearly\n\
3925 interpolated ignoring this circular property of hue. So for example,\n\
3926 the hues 0 (red) and 240 (blue) will get interpolated via yellow,\n\
3927 green and cyan. If instead you wish to interpolate the other way\n\
3928 around the color wheel you have two options. You may provide hues\n\
3929 outside the range [0, 360), so by using a hue of -120 for blue or 360\n\
3930 for red the interpolation will proceed via magenta. Alternatively you\n\
3931 can utilise the alt_hue_path variable to reverse the direction of\n\
3932 interpolation if you need to provide hues within the [0-360) range.\n\
3933 \n\
3934 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3935 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3936 -120]falsegreen-yellow-red-magenta-blue[240\n\
3937 480]falseblue-magenta-red-yellow-green[120\n\
3938 240]truegreen-yellow-red-magenta-blue[240\n\
3939 120]trueblue-magenta-red-yellow-green\n\
3940 \n\
3941 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3942 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3943 1]magnitudeHLSsaturation[0, 1]magnitude\n\
3944 \n\
3945 Redacted form: plscmap1l(itype, intensity, coord1, coord2, coord3,\n\
3946 alt_hue_path)\n\
3947 \n\
3948 This function is used in examples 8, 11, 12, 15, 20, and 21.\n\
3949 \n\
3950 \n\
3951 \n\
3952 SYNOPSIS:\n\
3953 \n\
3954 plscmap1l(itype, npts, intensity, coord1, coord2, coord3, alt_hue_path)\n\
3955 \n\
3956 ARGUMENTS:\n\
3957 \n\
3958 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
3959 \n\
3960 npts (PLINT, input) : number of control points\n\
3961 \n\
3962 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
3963 intensity index (0.0-1.0) in ascending order for each control\n\
3964 point.\n\
3965 \n\
3966 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
3967 coordinate (H or R) for each control point.\n\
3968 \n\
3969 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
3970 coordinate (L or G) for each control point.\n\
3971 \n\
3972 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
3973 coordinate (S or B) for each control point.\n\
3974 \n\
3975 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
3976 npts - 1 elements), each containing either true to use the reversed\n\
3977 HLS interpolation or false to use the regular HLS interpolation.\n\
3978 (alt_hue_path[i] refers to the interpolation interval between the\n\
3979 i and i + 1 control points). This parameter is not used for RGB\n\
3980 colors (\n\
3981 itype = true).\n\
3982 ";
3983 static const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
3984 Set the pause (on end-of-page) status\n\
3985 \n\
3986 DESCRIPTION:\n\
3987 \n\
3988 Set the pause (on end-of-page) status.\n\
3989 \n\
3990 Redacted form: plspause(pause)\n\
3991 \n\
3992 This function is in examples 14,20.\n\
3993 \n\
3994 \n\
3995 \n\
3996 SYNOPSIS:\n\
3997 \n\
3998 plspause(pause)\n\
3999 \n\
4000 ARGUMENTS:\n\
4001 \n\
4002 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
4003 end-of-page for those drivers which support this. Otherwise there\n\
4004 is no pause.\n\
4005 ";
4006 static const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
4007 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols\n\
4008 \n\
4009 DESCRIPTION:\n\
4010 \n\
4011 Routine for creating a discrete plot legend with a plotted filled box,\n\
4012 line, and/or line of symbols for each annotated legend entry. (See\n\
4013 plcolorbar for similar functionality for creating continuous color\n\
4014 bars.) The arguments of pllegend provide control over the location\n\
4015 and size of the legend as well as the location and characteristics of\n\
4016 the elements (most of which are optional) within that legend. The\n\
4017 resulting legend is clipped at the boundaries of the current subpage.\n\
4018 (N.B. the adopted coordinate system used for some of the parameters is\n\
4019 defined in the documentation of the position parameter.)\n\
4020 \n\
4021 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
4022 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
4023 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
4024 test_justification, text_colors, text, box_colors, box_patterns,\n\
4025 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
4026 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
4027 \n\
4028 This function is used in examples 4, 26, and 33.\n\
4029 \n\
4030 \n\
4031 \n\
4032 SYNOPSIS:\n\
4033 \n\
4034 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\
4035 \n\
4036 ARGUMENTS:\n\
4037 \n\
4038 p_legend_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4039 legend width in adopted coordinates. This quantity is calculated\n\
4040 from plot_width, text_offset, ncolumn (possibly modified inside\n\
4041 the routine depending on nlegend and nrow), and the length\n\
4042 (calculated internally) of the longest text string.\n\
4043 \n\
4044 p_legend_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
4045 legend height in adopted coordinates. This quantity is calculated\n\
4046 from text_scale, text_spacing, and nrow (possibly modified inside\n\
4047 the routine depending on nlegend and nrow).\n\
4048 \n\
4049 opt (PLINT, input) : opt contains bits controlling the overall\n\
4050 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
4051 on the left of the legend and the plotted area on the right.\n\
4052 Otherwise, put the text area on the right of the legend and the\n\
4053 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
4054 plot a (semitransparent) background for the legend. If the\n\
4055 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
4056 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
4057 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
4058 plot the resulting array of legend entries in row-major order.\n\
4059 Otherwise, plot the legend entries in column-major order.\n\
4060 \n\
4061 position (PLINT, input) : position contains bits which control the\n\
4062 overall position of the legend and the definition of the adopted\n\
4063 coordinates used for positions just like what is done for the\n\
4064 position argument for plcolorbar. However, note that the defaults\n\
4065 for the position bits (see below) are different than the\n\
4066 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
4067 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
4068 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
4069 the 16 possible standard positions (the 4 corners and centers of\n\
4070 the 4 sides for both the inside and outside cases) of the legend\n\
4071 relative to the adopted coordinate system. The corner positions\n\
4072 are specified by the appropriate combination of two of the\n\
4073 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
4074 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
4075 value of one of those bits. The adopted coordinates are\n\
4076 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
4077 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
4078 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
4079 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
4080 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
4081 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
4082 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
4083 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT.\n\
4084 \n\
4085 x (PLFLT, input) : X offset of the legend position in adopted\n\
4086 coordinates from the specified standard position of the legend.\n\
4087 For positive x, the direction of motion away from the standard\n\
4088 position is inward/outward from the standard corner positions or\n\
4089 standard left or right positions if the\n\
4090 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
4091 For the standard top or bottom positions, the direction of motion\n\
4092 is toward positive X.\n\
4093 \n\
4094 y (PLFLT, input) : Y offset of the legend position in adopted\n\
4095 coordinates from the specified standard position of the legend.\n\
4096 For positive y, the direction of motion away from the standard\n\
4097 position is inward/outward from the standard corner positions or\n\
4098 standard top or bottom positions if the\n\
4099 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. For\n\
4100 the standard left or right positions, the direction of motion is\n\
4101 toward positive Y.\n\
4102 \n\
4103 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
4104 of the plot area (where the colored boxes, lines, and/or lines of\n\
4105 symbols are drawn) of the legend.\n\
4106 \n\
4107 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
4108 legend (PL_LEGEND_BACKGROUND).\n\
4109 \n\
4110 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
4111 for the legend (PL_LEGEND_BOUNDING_BOX).\n\
4112 \n\
4113 bb_style (PLINT, input) : The pllsty style number for the\n\
4114 bounding-box line for the legend (PL_LEGEND_BACKGROUND).\n\
4115 \n\
4116 nrow (PLINT, input) : The number of rows in the matrix used to\n\
4117 render the\n\
4118 nlegend legend entries. For internal transformations of\n\
4119 nrow, see further remarks under\n\
4120 nlegend.\n\
4121 \n\
4122 ncolumn (PLINT, input) : The number of columns in the matrix used\n\
4123 to render the\n\
4124 nlegend legend entries. For internal transformations of\n\
4125 ncolumn, see further remarks under\n\
4126 nlegend.\n\
4127 \n\
4128 nlegend (PLINT, input) : Number of legend entries. The above\n\
4129 nrow and\n\
4130 ncolumn values are transformed internally to be consistent with\n\
4131 nlegend. If either\n\
4132 nrow or\n\
4133 ncolumn is non-positive it is replaced by 1. If the resulting product\n\
4134 of\n\
4135 nrow and\n\
4136 ncolumn is less than\n\
4137 nlegend, the smaller of the two (or\n\
4138 nrow, if\n\
4139 nrow ==\n\
4140 ncolumn) is increased so the product is >=\n\
4141 nlegend. Thus, for example, the common\n\
4142 nrow = 0,\n\
4143 ncolumn = 0 case is transformed internally to\n\
4144 nrow =\n\
4145 nlegend,\n\
4146 ncolumn = 1; i.e., the usual case of a legend rendered as a single\n\
4147 column.\n\
4148 \n\
4149 opt_array (PLINT_VECTOR, input) : A vector of\n\
4150 nlegend values of options to control each individual plotted area\n\
4151 corresponding to a legend entry. If the\n\
4152 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
4153 area. If the\n\
4154 PL_LEGEND_COLOR_BOX,\n\
4155 PL_LEGEND_LINE, and/or\n\
4156 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
4157 entry is plotted with a colored box; a line; and/or a line of\n\
4158 symbols.\n\
4159 \n\
4160 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
4161 area in units of character width.\n\
4162 \n\
4163 text_scale (PLFLT, input) : Character height scale for text\n\
4164 annotations.\n\
4165 \n\
4166 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
4167 character height from one legend entry to the next.\n\
4168 \n\
4169 text_justification (PLFLT, input) : Justification parameter used\n\
4170 for text justification. The most common values of\n\
4171 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
4172 is left justified, centred, or right justified within the text\n\
4173 area, but other values are allowed as well.\n\
4174 \n\
4175 text_colors (PLINT_VECTOR, input) : A vector containing\n\
4176 nlegend cmap0 text colors.\n\
4177 \n\
4178 text (PLCHAR_MATRIX, input) : A vector of\n\
4179 nlegend UTF-8 character strings containing the legend annotations.\n\
4180 \n\
4181 box_colors (PLINT_VECTOR, input) : A vector containing\n\
4182 nlegend cmap0 colors for the discrete colored boxes (\n\
4183 PL_LEGEND_COLOR_BOX).\n\
4184 \n\
4185 box_patterns (PLINT_VECTOR, input) : A vector containing\n\
4186 nlegend patterns (plpsty indices) for the discrete colored boxes (\n\
4187 PL_LEGEND_COLOR_BOX).\n\
4188 \n\
4189 box_scales (PLFLT_VECTOR, input) : A vector containing\n\
4190 nlegend scales (units of fraction of character height) for the height\n\
4191 of the discrete colored boxes (\n\
4192 PL_LEGEND_COLOR_BOX).\n\
4193 \n\
4194 box_line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4195 nlegend line widths for the patterns specified by box_patterns (\n\
4196 PL_LEGEND_COLOR_BOX).\n\
4197 \n\
4198 line_colors (PLINT_VECTOR, input) : A vector containing\n\
4199 nlegend cmap0 line colors (\n\
4200 PL_LEGEND_LINE).\n\
4201 \n\
4202 line_styles (PLINT_VECTOR, input) : A vector containing\n\
4203 nlegend line styles (plsty indices) (\n\
4204 PL_LEGEND_LINE).\n\
4205 \n\
4206 line_widths (PLFLT_VECTOR, input) : A vector containing\n\
4207 nlegend line widths (\n\
4208 PL_LEGEND_LINE).\n\
4209 \n\
4210 symbol_colors (PLINT_VECTOR, input) : A vector containing\n\
4211 nlegend cmap0 symbol colors (\n\
4212 PL_LEGEND_SYMBOL).\n\
4213 \n\
4214 symbol_scales (PLFLT_VECTOR, input) : A vector containing\n\
4215 nlegend scale values for the symbol height (\n\
4216 PL_LEGEND_SYMBOL).\n\
4217 \n\
4218 symbol_numbers (PLINT_VECTOR, input) : A vector containing\n\
4219 nlegend numbers of symbols to be drawn across the width of the plotted\n\
4220 area (\n\
4221 PL_LEGEND_SYMBOL).\n\
4222 \n\
4223 symbols (PLCHAR_MATRIX, input) : A vector of\n\
4224 nlegend UTF-8 character strings containing the legend symbols. (\n\
4225 PL_LEGEND_SYMBOL).\n\
4226 ";
4227 static const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
4228 Set number of colors in cmap1\n\
4229 \n\
4230 DESCRIPTION:\n\
4231 \n\
4232 Set number of colors in cmap1, (re-)allocate cmap1, and set default\n\
4233 values if this is the first allocation (see the PLplot documentation).\n\
4234 \n\
4235 Redacted form: plscmap1n(ncol1)\n\
4236 \n\
4237 This function is used in examples 8, 11, 20, and 21.\n\
4238 \n\
4239 \n\
4240 \n\
4241 SYNOPSIS:\n\
4242 \n\
4243 plscmap1n(ncol1)\n\
4244 \n\
4245 ARGUMENTS:\n\
4246 \n\
4247 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
4248 the cmap1 palette. If this number is zero or less, then the value\n\
4249 from the previous call to plscmap1n is used and if there is no\n\
4250 previous call, then a default value is used.\n\
4251 ";
4252 static const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
4253 Returns 8-bit RGB values and PLFLT alpha transparency value for given color index from cmap0\n\
4254 \n\
4255 DESCRIPTION:\n\
4256 \n\
4257 Returns 8-bit RGB values (0-255) and PLFLT alpha transparency value\n\
4258 (0.0-1.0) for given color from cmap0 (see the PLplot documentation).\n\
4259 Values are negative if an invalid color id is given.\n\
4260 \n\
4261 Redacted form: plgcola(r, g, b)\n\
4262 \n\
4263 This function is used in example 30.\n\
4264 \n\
4265 \n\
4266 \n\
4267 SYNOPSIS:\n\
4268 \n\
4269 plgcol0a(icol0, r, g, b, alpha)\n\
4270 \n\
4271 ARGUMENTS:\n\
4272 \n\
4273 icol0 (PLINT, input) : Index of desired cmap0 color.\n\
4274 \n\
4275 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
4276 in the range from 0 to 255.\n\
4277 \n\
4278 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
4279 in the range from 0 to 255.\n\
4280 \n\
4281 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
4282 in the range from 0 to 255.\n\
4283 \n\
4284 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
4285 transparency in the range from (0.0-1.0).\n\
4286 ";
4287 static const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
4288 Replays contents of plot buffer to current device/file\n\
4289 \n\
4290 DESCRIPTION:\n\
4291 \n\
4292 Replays contents of plot buffer to current device/file.\n\
4293 \n\
4294 Redacted form: plreplot()\n\
4295 \n\
4296 This function is used in example 1,20.\n\
4297 \n\
4298 \n\
4299 \n\
4300 SYNOPSIS:\n\
4301 \n\
4302 plreplot()\n\
4303 ";
4304 static const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
4305 Simple routine to write labels\n\
4306 \n\
4307 DESCRIPTION:\n\
4308 \n\
4309 Routine for writing simple labels. Use plmtex for more complex labels.\n\
4310 \n\
4311 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
4312 \n\
4313 This function is used in examples 1, 5, 9, 12, 14-16, 20-22, and 29.\n\
4314 \n\
4315 \n\
4316 \n\
4317 SYNOPSIS:\n\
4318 \n\
4319 pllab(xlabel, ylabel, tlabel)\n\
4320 \n\
4321 ARGUMENTS:\n\
4322 \n\
4323 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4324 the label for the x axis.\n\
4325 \n\
4326 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4327 the label for the y axis.\n\
4328 \n\
4329 tlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
4330 the title of the plot.\n\
4331 ";
4332 static const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
4333 Set parameters that define current device-space window\n\
4334 \n\
4335 DESCRIPTION:\n\
4336 \n\
4337 Set relative margin width, aspect ratio, and relative justification\n\
4338 that define current device-space window. If you want to just use the\n\
4339 previous value for any of these, just pass in the magic value\n\
4340 PL_NOTSET. It is unlikely that one should ever need to change the\n\
4341 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
4342 called the default values of mar, jx, and jy are all 0. aspect is set\n\
4343 to a device-specific value.\n\
4344 \n\
4345 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
4346 \n\
4347 This function is used in example 31.\n\
4348 \n\
4349 \n\
4350 \n\
4351 SYNOPSIS:\n\
4352 \n\
4353 plsdidev(mar, aspect, jx, jy)\n\
4354 \n\
4355 ARGUMENTS:\n\
4356 \n\
4357 mar (PLFLT, input) : Relative margin width.\n\
4358 \n\
4359 aspect (PLFLT, input) : Aspect ratio.\n\
4360 \n\
4361 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
4362 the range -0.5 to 0.5.\n\
4363 \n\
4364 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
4365 the range -0.5 to 0.5.\n\
4366 ";
4367 static const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
4368 Begin a new page\n\
4369 \n\
4370 DESCRIPTION:\n\
4371 \n\
4372 Begins a new page. For a file driver, the output file is opened if\n\
4373 necessary. Advancing the page via pleop and plbop is useful when a\n\
4374 page break is desired at a particular point when plotting to subpages.\n\
4375 Another use for pleop and plbop is when plotting pages to different\n\
4376 files, since you can manually set the file name by calling plsfnam\n\
4377 after the call to pleop. (In fact some drivers may only support a\n\
4378 single page per file, making this a necessity.) One way to handle\n\
4379 this case automatically is to page advance via pladv, but enable\n\
4380 familying (see plsfam) with a small limit on the file size so that a\n\
4381 new family member file will be created on each page break.\n\
4382 \n\
4383 Redacted form: plbop()\n\
4384 \n\
4385 This function is used in examples 2 and 20.\n\
4386 \n\
4387 \n\
4388 \n\
4389 SYNOPSIS:\n\
4390 \n\
4391 plbop()\n\
4392 ";
4393 static const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
4394 Set cmap0 colors by 8-bit RGB values\n\
4395 \n\
4396 DESCRIPTION:\n\
4397 \n\
4398 Set cmap0 colors using 8-bit RGB values (see the PLplot\n\
4399 documentation). This sets the entire color map -- only as many colors\n\
4400 as specified will be allocated.\n\
4401 \n\
4402 Redacted form: plscmap0(r, g, b)\n\
4403 \n\
4404 This function is used in examples 2 and 24.\n\
4405 \n\
4406 \n\
4407 \n\
4408 SYNOPSIS:\n\
4409 \n\
4410 plscmap0(r, g, b, ncol0)\n\
4411 \n\
4412 ARGUMENTS:\n\
4413 \n\
4414 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4415 integers (0-255) representing the degree of red in the color.\n\
4416 \n\
4417 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4418 integers (0-255) representing the degree of green in the color.\n\
4419 \n\
4420 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
4421 integers (0-255) representing the degree of blue in the color.\n\
4422 \n\
4423 ncol0 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4424 ";
4425 static const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
4426 Set the number of subpages in x and y\n\
4427 \n\
4428 DESCRIPTION:\n\
4429 \n\
4430 Set the number of subpages in x and y.\n\
4431 \n\
4432 Redacted form: plssub(nx, ny)\n\
4433 \n\
4434 This function is examples 1,2,14,21,25,27.\n\
4435 \n\
4436 \n\
4437 \n\
4438 SYNOPSIS:\n\
4439 \n\
4440 plssub(nx, ny)\n\
4441 \n\
4442 ARGUMENTS:\n\
4443 \n\
4444 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
4445 of window columns).\n\
4446 \n\
4447 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
4448 of window rows).\n\
4449 ";
4450 static const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
4451 Set a global coordinate transform function\n\
4452 \n\
4453 DESCRIPTION:\n\
4454 \n\
4455 This function can be used to define a coordinate transformation which\n\
4456 affects all elements drawn within the current plot window. The\n\
4457 coordinate_transform callback function is similar to that provided for\n\
4458 the plmap and plmeridians functions. The coordinate_transform_data\n\
4459 parameter may be used to pass extra data to coordinate_transform.\n\
4460 \n\
4461 Redacted form: General: plstransform(coordinate_transform,\n\
4462 coordinate_transform_data)\n\
4463 \n\
4464 \n\
4465 This function is used in examples 19 and 22.\n\
4466 \n\
4467 \n\
4468 \n\
4469 SYNOPSIS:\n\
4470 \n\
4471 plstransform(coordinate_transform, coordinate_transform_data)\n\
4472 \n\
4473 ARGUMENTS:\n\
4474 \n\
4475 coordinate_transform (PLTRANSFORM_callback, input) : A callback\n\
4476 function that defines the transformation from the input (x, y)\n\
4477 world coordinates to new PLplot world coordinates. If\n\
4478 coordinate_transform is not supplied (e.g., is set to NULL in the C\n\
4479 case), then no transform is applied.\n\
4480 \n\
4481 coordinate_transform_data (PLPointer, input) : Optional extra data\n\
4482 for\n\
4483 coordinate_transform.\n\
4484 ";
4485 static const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
4486 Set opaque RGB cmap1 colors values\n\
4487 \n\
4488 DESCRIPTION:\n\
4489 \n\
4490 Set opaque cmap1 colors (see the PLplot documentation) using RGB\n\
4491 vector values. This function also sets the number of cmap1 colors.\n\
4492 N.B. Continuous cmap1 colors are indexed with a floating-point index\n\
4493 in the range from 0.0-1.0 which is linearly transformed (e.g., by\n\
4494 plcol1) to an integer index of these RGB vectors in the range from 0\n\
4495 to\n\
4496 ncol1-1. So in order for this continuous color model to work\n\
4497 properly, it is the responsibility of the user of plscmap1 to insure\n\
4498 that these RGB vectors are continuous functions of their integer\n\
4499 indices.\n\
4500 \n\
4501 Redacted form: plscmap1(r, g, b)\n\
4502 \n\
4503 This function is used in example 31.\n\
4504 \n\
4505 \n\
4506 \n\
4507 SYNOPSIS:\n\
4508 \n\
4509 plscmap1(r, g, b, ncol1)\n\
4510 \n\
4511 ARGUMENTS:\n\
4512 \n\
4513 r (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4514 8-bit integers in the range from 0-255) the degree of red in the\n\
4515 color as a continuous function of the integer index of the vector.\n\
4516 \n\
4517 g (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4518 8-bit integers in the range from 0-255) the degree of green in the\n\
4519 color as a continuous function of the integer index of the vector.\n\
4520 \n\
4521 b (PLINT_VECTOR, input) : A vector that represents (using unsigned\n\
4522 8-bit integers in the range from 0-255) the degree of blue in the\n\
4523 color as a continuous function of the integer index of the vector.\n\
4524 \n\
4525 ncol1 (PLINT, input) : Number of items in the r, g, and b vectors.\n\
4526 ";
4527 static const char* _wrap_plconfigtime_texinfo = "-*- texinfo -*-\n\
4528 Configure the transformation between continuous and broken-down time for the current stream\n\
4529 \n\
4530 DESCRIPTION:\n\
4531 \n\
4532 Configure the transformation between continuous and broken-down time\n\
4533 for the current stream. This transformation is used by both plbtime\n\
4534 and plctime.\n\
4535 \n\
4536 Redacted form: General: plconfigtime(scale, offset1, offset2,\n\
4537 ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4538 \n\
4539 \n\
4540 This function is used in example 29.\n\
4541 \n\
4542 \n\
4543 \n\
4544 SYNOPSIS:\n\
4545 \n\
4546 plconfigtime(scale, offset1, offset2, ccontrol, ifbtime_offset, year, month, day, hour, min, sec)\n\
4547 \n\
4548 ARGUMENTS:\n\
4549 \n\
4550 scale (PLFLT, input) : The number of days per continuous time unit.\n\
4551 As a special case, if\n\
4552 scale is 0., then all other arguments are ignored, and the result (the\n\
4553 default used by PLplot) is the equivalent of a call to\n\
4554 plconfigtime(1./86400., 0., 0., 0x0, 1, 1970, 0, 1, 0, 0, 0.).\n\
4555 That is, for this special case broken-down time is calculated with\n\
4556 the proleptic Gregorian calendar with no leap seconds inserted,\n\
4557 and the continuous time is defined as the number of seconds since\n\
4558 the Unix epoch of 1970-01-01T00:00:00Z.\n\
4559 \n\
4560 offset1 (PLFLT, input) : If\n\
4561 ifbtime_offset is true, the parameters\n\
4562 offset1 and\n\
4563 offset2 are completely ignored. Otherwise, the sum of these parameters\n\
4564 (with units in days) specify the epoch of the continuous time\n\
4565 relative to the MJD epoch corresponding to the Gregorian calendar\n\
4566 date of 1858-11-17T00:00:00Z or JD = 2400000.5. Two PLFLT numbers\n\
4567 are used to specify the origin to allow users (by specifying\n\
4568 offset1 as an integer that can be exactly represented by a\n\
4569 floating-point variable and specifying\n\
4570 offset2 as a number in the range from 0. to 1) the chance to minimize\n\
4571 the numerical errors of the continuous time representation.\n\
4572 \n\
4573 offset2 (PLFLT, input) : See documentation of\n\
4574 offset1.\n\
4575 \n\
4576 ccontrol (PLINT, input) : ccontrol contains bits controlling the\n\
4577 transformation. If the 0x1 bit is set, then the proleptic Julian\n\
4578 calendar is used for broken-down time rather than the proleptic\n\
4579 Gregorian calendar. If the 0x2 bit is set, then leap seconds that\n\
4580 have been historically used to define UTC are inserted into the\n\
4581 broken-down time. Other possibilities for additional control bits\n\
4582 for ccontrol exist such as making the historical time corrections\n\
4583 in the broken-down time corresponding to ET (ephemeris time) or\n\
4584 making the (slightly non-constant) corrections from international\n\
4585 atomic time (TAI) to what astronomers define as terrestrial time\n\
4586 (TT). But those additional possibilities have not been\n\
4587 implemented yet in the qsastime library (one of the PLplot utility\n\
4588 libraries).\n\
4589 \n\
4590 ifbtime_offset (PLBOOL, input) : ifbtime_offset controls how the\n\
4591 epoch of the continuous time scale is specified by the user. If\n\
4592 ifbtime_offset is false, then\n\
4593 offset1 and\n\
4594 offset2 are used to specify the epoch, and the following broken-down\n\
4595 time parameters are completely ignored. If\n\
4596 ifbtime_offset is true, then\n\
4597 offset1 and\n\
4598 offset2 are completely ignored, and the following broken-down time\n\
4599 parameters are used to specify the epoch.\n\
4600 \n\
4601 year (PLINT, input) : Year of epoch.\n\
4602 \n\
4603 month (PLINT, input) : Month of epoch in range from 0 (January) to\n\
4604 11 (December).\n\
4605 \n\
4606 day (PLINT, input) : Day of epoch in range from 1 to 31.\n\
4607 \n\
4608 hour (PLINT, input) : Hour of epoch in range from 0 to 23\n\
4609 \n\
4610 min (PLINT, input) : Minute of epoch in range from 0 to 59.\n\
4611 \n\
4612 sec (PLFLT, input) : Second of epoch in range from 0. to 60.\n\
4613 ";
4614 static const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
4615 Set length of minor ticks\n\
4616 \n\
4617 DESCRIPTION:\n\
4618 \n\
4619 This sets up the length of the minor ticks and the length of the\n\
4620 terminals on error bars. The actual length is the product of the\n\
4621 default length and a scaling factor as for character height.\n\
4622 \n\
4623 Redacted form: plsmin(def, scale)\n\
4624 \n\
4625 This function is used in example 29.\n\
4626 \n\
4627 \n\
4628 \n\
4629 SYNOPSIS:\n\
4630 \n\
4631 plsmin(def, scale)\n\
4632 \n\
4633 ARGUMENTS:\n\
4634 \n\
4635 def (PLFLT, input) : The default length of a minor tick in\n\
4636 millimeters, should be set to zero if the default length is to\n\
4637 remain unchanged.\n\
4638 \n\
4639 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4640 actual tick length.\n\
4641 ";
4642 static const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
4643 Set character size\n\
4644 \n\
4645 DESCRIPTION:\n\
4646 \n\
4647 This sets up the size of all subsequent characters drawn. The actual\n\
4648 height of a character is the product of the default character size and\n\
4649 a scaling factor.\n\
4650 \n\
4651 Redacted form: plschr(def, scale)\n\
4652 \n\
4653 This function is used in examples 2, 13, 23, and 24.\n\
4654 \n\
4655 \n\
4656 \n\
4657 SYNOPSIS:\n\
4658 \n\
4659 plschr(def, scale)\n\
4660 \n\
4661 ARGUMENTS:\n\
4662 \n\
4663 def (PLFLT, input) : The default height of a character in\n\
4664 millimeters, should be set to zero if the default height is to\n\
4665 remain unchanged. For rasterized drivers the dx and dy values\n\
4666 specified in plspage are used to convert from mm to pixels (note\n\
4667 the different unit systems used). This dpi aware scaling is not\n\
4668 implemented for all drivers yet.\n\
4669 \n\
4670 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4671 actual character height.\n\
4672 ";
4673 static const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4674 Initialize PLplot\n\
4675 \n\
4676 DESCRIPTION:\n\
4677 \n\
4678 Initializing the plotting package. The program prompts for the device\n\
4679 keyword or number of the desired output device. Hitting a RETURN in\n\
4680 response to the prompt is the same as selecting the first device.\n\
4681 plinit will issue no prompt if either the device was specified\n\
4682 previously (via command line flag, the plsetopt function, or the\n\
4683 plsdev function), or if only one device is enabled when PLplot is\n\
4684 installed. If subpages have been specified, the output device is\n\
4685 divided into nx by ny subpages, each of which may be used\n\
4686 independently. If plinit is called again during a program, the\n\
4687 previously opened file will be closed. The subroutine pladv is used\n\
4688 to advance from one subpage to the next.\n\
4689 \n\
4690 Redacted form: plinit()\n\
4691 \n\
4692 This function is used in all of the examples.\n\
4693 \n\
4694 \n\
4695 \n\
4696 SYNOPSIS:\n\
4697 \n\
4698 plinit()\n\
4699 ";
4700 static const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4701 Draw a box with axes, etc\n\
4702 \n\
4703 DESCRIPTION:\n\
4704 \n\
4705 Draws a box around the currently defined viewport, and labels it with\n\
4706 world coordinate values appropriate to the window. Thus plbox should\n\
4707 only be called after defining both viewport and window. The ascii\n\
4708 character strings xopt and yopt specify how the box should be drawn as\n\
4709 described below. If ticks and/or subticks are to be drawn for a\n\
4710 particular axis, the tick intervals and number of subintervals may be\n\
4711 specified explicitly, or they may be defaulted by setting the\n\
4712 appropriate arguments to zero.\n\
4713 \n\
4714 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4715 \n\
4716 \n\
4717 This function is used in examples 1, 2, 4, 6, 6-12, 14-18, 21, 23-26,\n\
4718 and 29.\n\
4719 \n\
4720 \n\
4721 \n\
4722 SYNOPSIS:\n\
4723 \n\
4724 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4725 \n\
4726 ARGUMENTS:\n\
4727 \n\
4728 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4729 options for the x axis. The string can include any combination of\n\
4730 the following letters (upper or lower case) in any order: a: Draws\n\
4731 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
4732 (x=0).\n\
4733 b: Draws bottom (X) or left (Y) edge of frame.\n\
4734 c: Draws top (X) or right (Y) edge of frame.\n\
4735 d: Plot labels as date / time. Values are assumed to be\n\
4736 seconds since the epoch (as used by gmtime).\n\
4737 f: Always use fixed point numeric labels.\n\
4738 g: Draws a grid at the major tick interval.\n\
4739 h: Draws a grid at the minor tick interval.\n\
4740 i: Inverts tick marks, so they are drawn outwards, rather than\n\
4741 inwards.\n\
4742 l: Labels axis logarithmically. This only affects the labels,\n\
4743 not the data, and so it is necessary to compute the logarithms\n\
4744 of data points before passing them to any of the drawing\n\
4745 routines.\n\
4746 m: Writes numeric labels at major tick intervals in the\n\
4747 unconventional location (above box for X, right of box for Y).\n\
4748 n: Writes numeric labels at major tick intervals in the\n\
4749 conventional location (below box for X, left of box for Y).\n\
4750 o: Use custom labelling function to generate axis label text.\n\
4751 The custom labelling function can be defined with the\n\
4752 plslabelfunc command.\n\
4753 s: Enables subticks between major ticks, only valid if t is\n\
4754 also specified.\n\
4755 t: Draws major ticks.\n\
4756 u: Exactly like \"b\" except don\'t draw edge line.\n\
4757 w: Exactly like \"c\" except don\'t draw edge line.\n\
4758 x: Exactly like \"t\" (including the side effect of the\n\
4759 numerical labels for the major ticks) except exclude drawing\n\
4760 the major and minor tick marks.\n\
4761 \n\
4762 \n\
4763 xtick (PLFLT, input) : World coordinate interval between major\n\
4764 ticks on the x axis. If it is set to zero, PLplot automatically\n\
4765 generates a suitable tick interval.\n\
4766 \n\
4767 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4768 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4769 generates a suitable minor tick interval.\n\
4770 \n\
4771 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4772 options for the y axis. The string can include any combination of\n\
4773 the letters defined above for xopt, and in addition may contain:\n\
4774 v: Write numeric labels for the y axis parallel to the base of the\n\
4775 graph, rather than parallel to the axis.\n\
4776 \n\
4777 \n\
4778 ytick (PLFLT, input) : World coordinate interval between major\n\
4779 ticks on the y axis. If it is set to zero, PLplot automatically\n\
4780 generates a suitable tick interval.\n\
4781 \n\
4782 nysub (PLINT, input) : Number of subintervals between major y axis\n\
4783 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4784 generates a suitable minor tick interval.\n\
4785 ";
4786 static const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4787 Get parameters that define current device-space window\n\
4788 \n\
4789 DESCRIPTION:\n\
4790 \n\
4791 Get relative margin width, aspect ratio, and relative justification\n\
4792 that define current device-space window. If plsdidev has not been\n\
4793 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4794 p_jy will all be 0.\n\
4795 \n\
4796 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4797 \n\
4798 This function is used in example 31.\n\
4799 \n\
4800 \n\
4801 \n\
4802 SYNOPSIS:\n\
4803 \n\
4804 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4805 \n\
4806 ARGUMENTS:\n\
4807 \n\
4808 p_mar (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4809 margin width.\n\
4810 \n\
4811 p_aspect (PLFLT_NC_SCALAR, output) : Returned value of the aspect\n\
4812 ratio.\n\
4813 \n\
4814 p_jx (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4815 justification in x.\n\
4816 \n\
4817 p_jy (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
4818 justification in y.\n\
4819 ";
4820 static const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4821 Plot a glyph at the specified points\n\
4822 \n\
4823 DESCRIPTION:\n\
4824 \n\
4825 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4826 because many[!] more glyphs are accessible with plstring.) The glyph\n\
4827 is specified with a PLplot user string. Note that the user string is\n\
4828 not actually limited to one glyph so it is possible (but not normally\n\
4829 useful) to plot more than one glyph at the specified points with this\n\
4830 function. As with plmtex and plptex, the user string can contain FCI\n\
4831 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4832 else PLplot escapes for Hershey or unicode text to determine the\n\
4833 glyph.\n\
4834 \n\
4835 Redacted form: plstring(x, y, string)\n\
4836 \n\
4837 This function is used in examples 4, 21 and 26.\n\
4838 \n\
4839 \n\
4840 \n\
4841 SYNOPSIS:\n\
4842 \n\
4843 plstring(n, x, y, string)\n\
4844 \n\
4845 ARGUMENTS:\n\
4846 \n\
4847 n (PLINT, input) : Number of points in the x and y vectors.\n\
4848 \n\
4849 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
4850 the points.\n\
4851 \n\
4852 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
4853 the points.\n\
4854 \n\
4855 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
4856 the glyph(s) to be plotted at each of the n points.\n\
4857 ";
4858 static const char* _wrap_plmapstring_texinfo = "-*- texinfo -*-\n\
4859 Plot all or a subset of Shapefile data using strings or points in world coordinates\n\
4860 \n\
4861 DESCRIPTION:\n\
4862 \n\
4863 As per plmapline, however the items are plotted as strings or points\n\
4864 in the same way as plstring.\n\
4865 \n\
4866 Redacted form: plmapstring(mapform, name, string, minx, maxx, miny,\n\
4867 maxy, plotentries)\n\
4868 \n\
4869 This function is not used in any examples.\n\
4870 \n\
4871 \n\
4872 \n\
4873 SYNOPSIS:\n\
4874 \n\
4875 plmapstring(mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
4876 \n\
4877 ARGUMENTS:\n\
4878 \n\
4879 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
4880 transform the coordinates given in the shapefile into a plot\n\
4881 coordinate system. By using this transform, we can change from a\n\
4882 longitude, latitude coordinate to a polar stereographic project,\n\
4883 for example. Initially, x[0]..[n-1] are the longitudes and\n\
4884 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
4885 mapform(), x[] and y[] should be replaced by the corresponding\n\
4886 plot coordinates. If no transform is desired, mapform can be\n\
4887 replaced by NULL.\n\
4888 \n\
4889 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
4890 the file name of a set of Shapefile files without the file\n\
4891 extension.\n\
4892 \n\
4893 string (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
4894 drawn.\n\
4895 \n\
4896 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
4897 be in the same units as used by the Shapefile. You could use a\n\
4898 very large negative number to plot everything, but you can improve\n\
4899 performance by limiting the area drawn. The units must match those\n\
4900 of the Shapefile projection, which may be for example longitude or\n\
4901 distance. The value of minx must be less than the value of maxx.\n\
4902 \n\
4903 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
4904 use a very large number to plot everything, but you can improve\n\
4905 performance by limiting the area drawn.\n\
4906 \n\
4907 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
4908 be in the same units as used by the Shapefile. You could use a\n\
4909 very large negative number to plot everything, but you can improve\n\
4910 performance by limiting the area drawn. The units must match those\n\
4911 of the Shapefile projection, which may be for example latitude or\n\
4912 distance. The value of miny must be less than the value of maxy.\n\
4913 \n\
4914 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
4915 use a very large number to plot everything, but you can improve\n\
4916 performance by limiting the area drawn.\n\
4917 \n\
4918 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
4919 zero-based indices of the Shapefile elements which will be drawn.\n\
4920 Setting\n\
4921 plotentries to NULL will plot all elements of the Shapefile.\n\
4922 \n\
4923 nplotentries (PLINT, input) : The number of items in\n\
4924 plotentries. Ignored if\n\
4925 plotentries is NULL.\n\
4926 ";
4927 static const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
4928 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it\n\
4929 \n\
4930 DESCRIPTION:\n\
4931 \n\
4932 Sets up plotter environment for simple graphs by calling pladv and\n\
4933 setting up viewport and window to sensible default values. plenv0\n\
4934 leaves a standard margin (left-hand margin of eight character heights,\n\
4935 and a margin around the other three sides of five character heights)\n\
4936 around most graphs for axis labels and a title. When these defaults\n\
4937 are not suitable, use the individual routines plvpas, plvpor, or\n\
4938 plvasp for setting up the viewport, plwind for defining the window,\n\
4939 and plbox for drawing the box.\n\
4940 \n\
4941 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4942 \n\
4943 This function is used in example 21.\n\
4944 \n\
4945 \n\
4946 \n\
4947 SYNOPSIS:\n\
4948 \n\
4949 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4950 \n\
4951 ARGUMENTS:\n\
4952 \n\
4953 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4954 world coordinates).\n\
4955 \n\
4956 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4957 world coordinates).\n\
4958 \n\
4959 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4960 coordinates).\n\
4961 \n\
4962 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4963 coordinates).\n\
4964 \n\
4965 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4966 scales will not be set, the user must set up the scale before\n\
4967 calling plenv0 using plsvpa, plvasp or other.\n\
4968 0: the x and y axes are scaled independently to use as much of\n\
4969 the screen as possible.\n\
4970 1: the scales of the x and y axes are made equal.\n\
4971 2: the axis of the x and y axes are made equal, and the plot\n\
4972 box will be square.\n\
4973 \n\
4974 \n\
4975 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4976 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
4977 -1: draw box only.\n\
4978 0: draw box, ticks, and numeric tick labels.\n\
4979 1: also draw coordinate axes at x=0 and y=0.\n\
4980 2: also draw a grid at major tick positions in both\n\
4981 coordinates.\n\
4982 3: also draw a grid at minor tick positions in both\n\
4983 coordinates.\n\
4984 10: same as 0 except logarithmic x tick marks. (The x data\n\
4985 have to be converted to logarithms separately.)\n\
4986 11: same as 1 except logarithmic x tick marks. (The x data\n\
4987 have to be converted to logarithms separately.)\n\
4988 12: same as 2 except logarithmic x tick marks. (The x data\n\
4989 have to be converted to logarithms separately.)\n\
4990 13: same as 3 except logarithmic x tick marks. (The x data\n\
4991 have to be converted to logarithms separately.)\n\
4992 20: same as 0 except logarithmic y tick marks. (The y data\n\
4993 have to be converted to logarithms separately.)\n\
4994 21: same as 1 except logarithmic y tick marks. (The y data\n\
4995 have to be converted to logarithms separately.)\n\
4996 22: same as 2 except logarithmic y tick marks. (The y data\n\
4997 have to be converted to logarithms separately.)\n\
4998 23: same as 3 except logarithmic y tick marks. (The y data\n\
4999 have to be converted to logarithms separately.)\n\
5000 30: same as 0 except logarithmic x and y tick marks. (The x\n\
5001 and y data have to be converted to logarithms separately.)\n\
5002 31: same as 1 except logarithmic x and y tick marks. (The x\n\
5003 and y data have to be converted to logarithms separately.)\n\
5004 32: same as 2 except logarithmic x and y tick marks. (The x\n\
5005 and y data have to be converted to logarithms separately.)\n\
5006 33: same as 3 except logarithmic x and y tick marks. (The x\n\
5007 and y data have to be converted to logarithms separately.)\n\
5008 40: same as 0 except date / time x labels.\n\
5009 41: same as 1 except date / time x labels.\n\
5010 42: same as 2 except date / time x labels.\n\
5011 43: same as 3 except date / time x labels.\n\
5012 50: same as 0 except date / time y labels.\n\
5013 51: same as 1 except date / time y labels.\n\
5014 52: same as 2 except date / time y labels.\n\
5015 53: same as 3 except date / time y labels.\n\
5016 60: same as 0 except date / time x and y labels.\n\
5017 61: same as 1 except date / time x and y labels.\n\
5018 62: same as 2 except date / time x and y labels.\n\
5019 63: same as 3 except date / time x and y labels.\n\
5020 70: same as 0 except custom x and y labels.\n\
5021 71: same as 1 except custom x and y labels.\n\
5022 72: same as 2 except custom x and y labels.\n\
5023 73: same as 3 except custom x and y labels.\n\
5024 ";
5025 static const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
5026 Configure the transformations required for projecting a 3D surface on a 2D window\n\
5027 \n\
5028 DESCRIPTION:\n\
5029 \n\
5030 Configure the transformations required for projecting a 3D surface on\n\
5031 an existing 2D window. Those transformations (see the PLplot\n\
5032 documentation) are done to a rectangular cuboid enclosing the 3D\n\
5033 surface which has its limits expressed in 3D world coordinates and\n\
5034 also normalized 3D coordinates (used for interpreting the altitude and\n\
5035 azimuth of the viewing angle). The transformations consist of the\n\
5036 linear transform from 3D world coordinates to normalized 3D\n\
5037 coordinates, and the 3D rotation of normalized coordinates required to\n\
5038 align the pole of the new 3D coordinate system with the viewing\n\
5039 direction specified by altitude and azimuth so that x and y of the\n\
5040 surface elements in that transformed coordinate system are the\n\
5041 projection of the 3D surface with given viewing direction on the 2D\n\
5042 window.\n\
5043 \n\
5044 The enclosing rectangular cuboid for the surface plot is defined by\n\
5045 xmin, xmax, ymin, ymax, zmin and zmax in 3D world coordinates. It is\n\
5046 mapped into the same rectangular cuboid with normalized 3D coordinate\n\
5047 sizes of basex by basey by height so that xmin maps to -\n\
5048 basex/2, xmax maps to basex/2, ymin maps to -\n\
5049 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
5050 The resulting rectangular cuboid in normalized coordinates is then\n\
5051 viewed by an observer at altitude alt and azimuth az. This routine\n\
5052 must be called before plbox3 or any of the 3D surface plotting\n\
5053 routines; plmesh, plmeshc, plot3d, plot3dc, plot3dcl, plsurf3d,\n\
5054 plsurf3dl or plfill3.\n\
5055 \n\
5056 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
5057 zmin, zmax, alt, az)\n\
5058 \n\
5059 This function is examples 8, 11, 18, and 21.\n\
5060 \n\
5061 \n\
5062 \n\
5063 SYNOPSIS:\n\
5064 \n\
5065 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
5066 \n\
5067 ARGUMENTS:\n\
5068 \n\
5069 basex (PLFLT, input) : The normalized x coordinate size of the\n\
5070 rectangular cuboid.\n\
5071 \n\
5072 basey (PLFLT, input) : The normalized y coordinate size of the\n\
5073 rectangular cuboid.\n\
5074 \n\
5075 height (PLFLT, input) : The normalized z coordinate size of the\n\
5076 rectangular cuboid.\n\
5077 \n\
5078 xmin (PLFLT, input) : The minimum x world coordinate of the\n\
5079 rectangular cuboid.\n\
5080 \n\
5081 xmax (PLFLT, input) : The maximum x world coordinate of the\n\
5082 rectangular cuboid.\n\
5083 \n\
5084 ymin (PLFLT, input) : The minimum y world coordinate of the\n\
5085 rectangular cuboid.\n\
5086 \n\
5087 ymax (PLFLT, input) : The maximum y world coordinate of the\n\
5088 rectangular cuboid.\n\
5089 \n\
5090 zmin (PLFLT, input) : The minimum z world coordinate of the\n\
5091 rectangular cuboid.\n\
5092 \n\
5093 zmax (PLFLT, input) : The maximum z world coordinate of the\n\
5094 rectangular cuboid.\n\
5095 \n\
5096 alt (PLFLT, input) : The viewing altitude in degrees above the xy\n\
5097 plane of the rectangular cuboid in normalized coordinates.\n\
5098 \n\
5099 az (PLFLT, input) : The viewing azimuth in degrees of the\n\
5100 rectangular cuboid in normalized coordinates. When az=0, the\n\
5101 observer is looking face onto the zx plane of the rectangular\n\
5102 cuboid in normalized coordinates, and as az is increased, the\n\
5103 observer moves clockwise around that cuboid when viewed from above\n\
5104 the xy plane.\n\
5105 ";
5106 static const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
5107 Draw filled polygon\n\
5108 \n\
5109 DESCRIPTION:\n\
5110 \n\
5111 Fills the polygon defined by the n points (\n\
5112 x[i],\n\
5113 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
5114 style is a solid fill. The routine will automatically close the\n\
5115 polygon between the last and first vertices. If multiple closed\n\
5116 polygons are passed in x and y then plfill will fill in between them.\n\
5117 \n\
5118 Redacted form: plfill(x,y)\n\
5119 \n\
5120 This function is used in examples 12, 13, 15, 16, 21, 24, and 25.\n\
5121 \n\
5122 \n\
5123 \n\
5124 SYNOPSIS:\n\
5125 \n\
5126 plfill(n, x, y)\n\
5127 \n\
5128 ARGUMENTS:\n\
5129 \n\
5130 n (PLINT, input) : Number of vertices in polygon.\n\
5131 \n\
5132 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
5133 vertices.\n\
5134 \n\
5135 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
5136 vertices.\n\
5137 ";
5138 static const char* _wrap_plot3dc_texinfo = "-*- texinfo -*-\n\
5139 Magnitude colored plot surface with contour\n\
5140 \n\
5141 DESCRIPTION:\n\
5142 \n\
5143 Aside from dropping the\n\
5144 side functionality this is a more powerful form of plot3d: the surface\n\
5145 mesh can be colored accordingly to the current z value being plotted,\n\
5146 a contour plot can be drawn at the base XY plane, and a curtain can be\n\
5147 drawn between the plotted function border and the base XY plane. The\n\
5148 arguments are identical to those of plmeshc. The only difference\n\
5149 between plmeshc and plot3dc is that plmeshc draws the bottom side of\n\
5150 the surface, while plot3dc only draws the surface as viewed from the\n\
5151 top.\n\
5152 \n\
5153 Redacted form: General: plot3dc(x, y, z, opt, clevel)\n\
5154 \n\
5155 \n\
5156 This function is used in example 21.\n\
5157 \n\
5158 \n\
5159 \n\
5160 SYNOPSIS:\n\
5161 \n\
5162 plot3dc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
5163 \n\
5164 ARGUMENTS:\n\
5165 \n\
5166 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5167 which the function is evaluated.\n\
5168 \n\
5169 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5170 which the function is evaluated.\n\
5171 \n\
5172 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5173 plot. Should have dimensions of\n\
5174 nx by\n\
5175 ny.\n\
5176 \n\
5177 nx (PLINT, input) : Number of x values at which function is\n\
5178 evaluated.\n\
5179 \n\
5180 ny (PLINT, input) : Number of y values at which function is\n\
5181 evaluated.\n\
5182 \n\
5183 opt (PLINT, input) : Determines the way in which the surface is\n\
5184 represented. To specify more than one option just add the options,\n\
5185 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
5186 showing z as a function of x for each value of y[j] .\n\
5187 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5188 for each value of x[i] .\n\
5189 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5190 at which function is defined.\n\
5191 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
5192 the z value being plotted. The color is used from the current\n\
5193 cmap1.\n\
5194 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5195 using parameters\n\
5196 nlevel and\n\
5197 clevel.\n\
5198 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5199 the borders of the plotted function.\n\
5200 \n\
5201 \n\
5202 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5203 levels.\n\
5204 \n\
5205 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5206 ";
5207 static const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
5208 Write text relative to viewport boundaries\n\
5209 \n\
5210 DESCRIPTION:\n\
5211 \n\
5212 Writes text at a specified position relative to the viewport\n\
5213 boundaries. Text may be written inside or outside the viewport, but\n\
5214 is clipped at the subpage boundaries. The reference point of a string\n\
5215 lies along a line passing through the string at half the height of a\n\
5216 capital letter. The position of the reference point along this line\n\
5217 is determined by just, and the position of the reference point\n\
5218 relative to the viewport is set by disp and pos.\n\
5219 \n\
5220 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
5221 \n\
5222 \n\
5223 This function is used in examples 3, 4, 6-8, 11, 12, 14, 18, 23, and\n\
5224 26.\n\
5225 \n\
5226 \n\
5227 \n\
5228 SYNOPSIS:\n\
5229 \n\
5230 plmtex(side, disp, pos, just, text)\n\
5231 \n\
5232 ARGUMENTS:\n\
5233 \n\
5234 side (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
5235 the side of the viewport along which the text is to be written.\n\
5236 The string must be one of: b: Bottom of viewport, text written\n\
5237 parallel to edge.\n\
5238 bv: Bottom of viewport, text written at right angles to edge.\n\
5239 l: Left of viewport, text written parallel to edge.\n\
5240 lv: Left of viewport, text written at right angles to edge.\n\
5241 r: Right of viewport, text written parallel to edge.\n\
5242 rv: Right of viewport, text written at right angles to edge.\n\
5243 t: Top of viewport, text written parallel to edge.\n\
5244 tv: Top of viewport, text written at right angles to edge.\n\
5245 \n\
5246 \n\
5247 disp (PLFLT, input) : Position of the reference point of string,\n\
5248 measured outwards from the specified viewport edge in units of the\n\
5249 current character height. Use negative disp to write within the\n\
5250 viewport.\n\
5251 \n\
5252 pos (PLFLT, input) : Position of the reference point of string\n\
5253 along the specified edge, expressed as a fraction of the length of\n\
5254 the edge.\n\
5255 \n\
5256 just (PLFLT, input) : Specifies the position of the string relative\n\
5257 to its reference point. If just=0. , the reference point is at\n\
5258 the left and if just=1. , it is at the right of the string. Other\n\
5259 values of just give intermediate justifications.\n\
5260 \n\
5261 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5262 written out.\n\
5263 ";
5264 static const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
5265 Set arrow style for vector plots\n\
5266 \n\
5267 DESCRIPTION:\n\
5268 \n\
5269 Set the style for the arrow used by plvect to plot vectors.\n\
5270 \n\
5271 Redacted form: plsvect(arrowx, arrowy, fill)\n\
5272 \n\
5273 This function is used in example 22.\n\
5274 \n\
5275 \n\
5276 \n\
5277 SYNOPSIS:\n\
5278 \n\
5279 plsvect(arrowx, arrowy, npts, fill)\n\
5280 \n\
5281 ARGUMENTS:\n\
5282 \n\
5283 arrowx, arrowy (PLFLT_VECTOR, input) : A pair of vectors containing\n\
5284 the x and y points which make up the arrow. The arrow is plotted\n\
5285 by joining these points to form a polygon. The scaling assumes\n\
5286 that the x and y points in the arrow lie in the range -0.5 <= x,y\n\
5287 <= 0.5. If both arrowx and arrowy are NULL then the arrow style\n\
5288 will be reset to its default.\n\
5289 \n\
5290 npts (PLINT, input) : Number of points in the vectors arrowx and\n\
5291 arrowy.\n\
5292 \n\
5293 fill (PLBOOL, input) : If fill is true then the arrow is closed, if\n\
5294 fill is false then the arrow is open.\n\
5295 ";
5296 static const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
5297 Get family file parameters\n\
5298 \n\
5299 DESCRIPTION:\n\
5300 \n\
5301 Gets information about current family file, if familying is enabled.\n\
5302 See the PLplot documentation for more information.\n\
5303 \n\
5304 Redacted form: plgfam(p_fam, p_num, p_bmax)\n\
5305 \n\
5306 This function is used in examples 14 and 31.\n\
5307 \n\
5308 \n\
5309 \n\
5310 SYNOPSIS:\n\
5311 \n\
5312 plgfam(p_fam, p_num, p_bmax)\n\
5313 \n\
5314 ARGUMENTS:\n\
5315 \n\
5316 p_fam (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5317 family flag value. If nonzero, familying is enabled for the\n\
5318 current device.\n\
5319 \n\
5320 p_num (PLINT_NC_SCALAR, output) : Returned value of the current\n\
5321 family file number.\n\
5322 \n\
5323 p_bmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5324 file size (in bytes) for a family file.\n\
5325 ";
5326 static const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
5327 Random number generator returning a real random number in the range [0,1]\n\
5328 \n\
5329 DESCRIPTION:\n\
5330 \n\
5331 Random number generator returning a real random number in the range\n\
5332 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
5333 / compilers provide their own random number generator, and so this is\n\
5334 provided purely for convenience and to give a consistent random number\n\
5335 generator across all languages supported by PLplot. This is\n\
5336 particularly useful for comparing results from the test suite of\n\
5337 examples.\n\
5338 \n\
5339 Redacted form: plrandd()\n\
5340 \n\
5341 This function is used in examples 17 and 21.\n\
5342 \n\
5343 \n\
5344 \n\
5345 SYNOPSIS:\n\
5346 \n\
5347 plrandd()\n\
5348 ";
5349 static const char* _wrap_plcont_texinfo = "-*- texinfo -*-\n\
5350 Contour plot\n\
5351 \n\
5352 DESCRIPTION:\n\
5353 \n\
5354 Draws a contour plot of the data in f[\n\
5355 nx][\n\
5356 ny], using the nlevel contour levels specified by clevel. Only the\n\
5357 region of the matrix from kx to lx and from ky to ly is plotted out\n\
5358 where all these index ranges are interpreted as one-based for\n\
5359 historical reasons. A transformation routine pointed to by pltr with\n\
5360 a generic pointer pltr_data for additional data required by the\n\
5361 transformation routine is used to map indices within the matrix to the\n\
5362 world coordinates.\n\
5363 \n\
5364 Redacted form: plcont(f, kx, lx, ky, ly, clevel, pltr, pltr_data)\n\
5365 where (see above discussion) the pltr, pltr_data callback arguments\n\
5366 are sometimes replaced by a tr vector with 6 elements; xg and yg\n\
5367 vectors; or xg and yg matrices.\n\
5368 \n\
5369 This function is used in examples 9, 14, 16, and 22.\n\
5370 \n\
5371 \n\
5372 \n\
5373 SYNOPSIS:\n\
5374 \n\
5375 plcont(f, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr, pltr_data)\n\
5376 \n\
5377 ARGUMENTS:\n\
5378 \n\
5379 f (PLFLT_MATRIX, input) : A matrix containing data to be contoured.\n\
5380 \n\
5381 nx, ny (PLINT, input) : The dimensions of the matrix f.\n\
5382 \n\
5383 kx, lx (PLINT, input) : Range of x indices to consider where 0 <=\n\
5384 kx-1 < lx-1 < nx. Values of kx and lx are one-based rather than\n\
5385 zero-based for historical backwards-compatibility reasons.\n\
5386 \n\
5387 ky, ly (PLINT, input) : Range of y indices to consider where 0 <=\n\
5388 ky-1 < ly-1 < ny. Values of ky and ly are one-based rather than\n\
5389 zero-based for historical backwards-compatibility reasons.\n\
5390 \n\
5391 clevel (PLFLT_VECTOR, input) : A vector specifying the levels at\n\
5392 which to draw contours.\n\
5393 \n\
5394 nlevel (PLINT, input) : Number of contour levels to draw.\n\
5395 \n\
5396 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
5397 defines the transformation between the zero-based indices of the\n\
5398 matrix f and the world coordinates.For the C case, transformation\n\
5399 functions are provided in the PLplot library: pltr0 for the\n\
5400 identity mapping, and pltr1 and pltr2 for arbitrary mappings\n\
5401 respectively defined by vectors and matrices. In addition, C\n\
5402 callback routines for the transformation can be supplied by the\n\
5403 user such as the mypltr function in examples/c/x09c.c which\n\
5404 provides a general linear transformation between index coordinates\n\
5405 and world coordinates.For languages other than C you should\n\
5406 consult the PLplot documentation for the details concerning how\n\
5407 PLTRANSFORM_callback arguments are interfaced. However, in\n\
5408 general, a particular pattern of callback-associated arguments\n\
5409 such as a tr vector with 6 elements; xg and yg vectors; or xg and\n\
5410 yg matrices are respectively interfaced to a linear-transformation\n\
5411 routine similar to the above mypltr function; pltr1; and pltr2.\n\
5412 Furthermore, some of our more sophisticated bindings (see, e.g.,\n\
5413 the PLplot documentation) support native language callbacks for\n\
5414 handling index to world-coordinate transformations. Examples of\n\
5415 these various approaches are given in examples/<language>x09*,\n\
5416 examples/<language>x16*, examples/<language>x20*,\n\
5417 examples/<language>x21*, and examples/<language>x22*, for all our\n\
5418 supported languages.\n\
5419 \n\
5420 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
5421 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
5422 that is externally supplied.\n\
5423 ";
5424 static const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
5425 Set line style\n\
5426 \n\
5427 DESCRIPTION:\n\
5428 \n\
5429 This sets up the line style for all lines subsequently drawn. A line\n\
5430 consists of segments in which the pen is alternately down and up. The\n\
5431 lengths of these segments are passed in the vectors mark and space\n\
5432 respectively. The number of mark-space pairs is specified by nms. In\n\
5433 order to return the line style to the default continuous line, plstyl\n\
5434 should be called with nms =0 .(see also pllsty)\n\
5435 \n\
5436 Redacted form: plstyl(mark, space)\n\
5437 \n\
5438 This function is used in examples 1, 9, and 14.\n\
5439 \n\
5440 \n\
5441 \n\
5442 SYNOPSIS:\n\
5443 \n\
5444 plstyl(nms, mark, space)\n\
5445 \n\
5446 ARGUMENTS:\n\
5447 \n\
5448 nms (PLINT, input) : The number of mark and space elements in a\n\
5449 line. Thus a simple broken line can be obtained by setting nms=1\n\
5450 . A continuous line is specified by setting nms=0 .\n\
5451 \n\
5452 mark (PLINT_VECTOR, input) : A vector containing the lengths of the\n\
5453 segments during which the pen is down, measured in micrometers.\n\
5454 \n\
5455 space (PLINT_VECTOR, input) : A vector containing the lengths of\n\
5456 the segments during which the pen is up, measured in micrometers.\n\
5457 ";
5458 static const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
5459 Set the cmap0 palette using the specified cmap0*.pal format file\n\
5460 \n\
5461 DESCRIPTION:\n\
5462 \n\
5463 Set the cmap0 palette using the specified cmap0*.pal format file.\n\
5464 \n\
5465 Redacted form: plspal0(filename)\n\
5466 \n\
5467 This function is in example 16.\n\
5468 \n\
5469 \n\
5470 \n\
5471 SYNOPSIS:\n\
5472 \n\
5473 plspal0(filename)\n\
5474 \n\
5475 ARGUMENTS:\n\
5476 \n\
5477 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5478 containing the name of the cmap0*.pal file. If this string is\n\
5479 empty, use the default cmap0*.pal file.\n\
5480 ";
5481 static const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
5482 Set the cmap1 palette using the specified cmap1*.pal format file\n\
5483 \n\
5484 DESCRIPTION:\n\
5485 \n\
5486 Set the cmap1 palette using the specified cmap1*.pal format file.\n\
5487 \n\
5488 Redacted form: plspal1(filename, interpolate)\n\
5489 \n\
5490 This function is used in example 16.\n\
5491 \n\
5492 \n\
5493 \n\
5494 SYNOPSIS:\n\
5495 \n\
5496 plspal1(filename, interpolate)\n\
5497 \n\
5498 ARGUMENTS:\n\
5499 \n\
5500 filename (PLCHAR_VECTOR, input) : An ascii character string\n\
5501 containing the name of the cmap1*.pal file. If this string is\n\
5502 empty, use the default cmap1*.pal file.\n\
5503 \n\
5504 interpolate (PLBOOL, input) : If this parameter is true, the\n\
5505 columns containing the intensity index, r, g, b, alpha and\n\
5506 alt_hue_path in the cmap1*.pal file are used to set the cmap1\n\
5507 palette with a call to plscmap1la. (The cmap1*.pal header contains\n\
5508 a flag which controls whether the r, g, b data sent to plscmap1la\n\
5509 are interpreted as HLS or RGB.) If this parameter is false, the\n\
5510 intensity index and alt_hue_path columns are ignored and the r, g,\n\
5511 b (interpreted as RGB), and alpha columns of the cmap1*.pal file\n\
5512 are used instead to set the cmap1 palette directly with a call to\n\
5513 plscmap1a.\n\
5514 ";
5515 static const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
5516 Set current output stream\n\
5517 \n\
5518 DESCRIPTION:\n\
5519 \n\
5520 Sets the number of the current output stream. The stream number\n\
5521 defaults to 0 unless changed by this routine. The first use of this\n\
5522 routine must be followed by a call initializing PLplot (e.g. plstar).\n\
5523 \n\
5524 Redacted form: plsstrm(strm)\n\
5525 \n\
5526 This function is examples 1,14,20.\n\
5527 \n\
5528 \n\
5529 \n\
5530 SYNOPSIS:\n\
5531 \n\
5532 plsstrm(strm)\n\
5533 \n\
5534 ARGUMENTS:\n\
5535 \n\
5536 strm (PLINT, input) : The current stream number.\n\
5537 ";
5538 static const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
5539 Specify viewport using normalized subpage coordinates\n\
5540 \n\
5541 DESCRIPTION:\n\
5542 \n\
5543 Device-independent routine for setting up the viewport. This defines\n\
5544 the viewport in terms of normalized subpage coordinates which run from\n\
5545 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
5546 current subpage. Use the alternate routine plsvpa in order to create\n\
5547 a viewport of a definite size.\n\
5548 \n\
5549 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
5550 \n\
5551 This function is used in examples 2, 6-8, 10, 11, 15, 16, 18, 21, 23,\n\
5552 24, 26, 27, and 31.\n\
5553 \n\
5554 \n\
5555 \n\
5556 SYNOPSIS:\n\
5557 \n\
5558 plvpor(xmin, xmax, ymin, ymax)\n\
5559 \n\
5560 ARGUMENTS:\n\
5561 \n\
5562 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5563 left-hand edge of the viewport.\n\
5564 \n\
5565 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5566 right-hand edge of the viewport.\n\
5567 \n\
5568 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5569 bottom edge of the viewport.\n\
5570 \n\
5571 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5572 edge of the viewport.\n\
5573 ";
5574 static const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
5575 Write text inside the viewport\n\
5576 \n\
5577 DESCRIPTION:\n\
5578 \n\
5579 Writes text at a specified position and inclination within the\n\
5580 viewport. Text is clipped at the viewport boundaries. The reference\n\
5581 point of a string lies along a line passing through the string at half\n\
5582 the height of a capital letter. The position of the reference point\n\
5583 along this line is determined by just, the reference point is placed\n\
5584 at world coordinates (\n\
5585 x,\n\
5586 y) within the viewport. The inclination of the string is specified\n\
5587 in terms of differences of world coordinates making it easy to write\n\
5588 text parallel to a line in a graph.\n\
5589 \n\
5590 Redacted form: plptex(x, y, dx, dy, just, text)\n\
5591 \n\
5592 This function is used in example 2-4,10,12-14,20,23,24,26.\n\
5593 \n\
5594 \n\
5595 \n\
5596 SYNOPSIS:\n\
5597 \n\
5598 plptex(x, y, dx, dy, just, text)\n\
5599 \n\
5600 ARGUMENTS:\n\
5601 \n\
5602 x (PLFLT, input) : x coordinate of reference point of string.\n\
5603 \n\
5604 y (PLFLT, input) : y coordinate of reference point of string.\n\
5605 \n\
5606 dx (PLFLT, input) : Together with dy, this specifies the\n\
5607 inclination of the string. The baseline of the string is parallel\n\
5608 to a line joining (\n\
5609 x,\n\
5610 y) to (\n\
5611 x+\n\
5612 dx,\n\
5613 y+\n\
5614 dy) .\n\
5615 \n\
5616 dy (PLFLT, input) : Together with dx, this specifies the\n\
5617 inclination of the string.\n\
5618 \n\
5619 just (PLFLT, input) : Specifies the position of the string relative\n\
5620 to its reference point. If just=0. , the reference point is at\n\
5621 the left and if just=1. , it is at the right of the string. Other\n\
5622 values of just give intermediate justifications.\n\
5623 \n\
5624 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
5625 written out.\n\
5626 ";
5627 static const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
5628 Set z axis parameters\n\
5629 \n\
5630 DESCRIPTION:\n\
5631 \n\
5632 Identical to plsxax, except that arguments are flags for z axis. See\n\
5633 the description of plsxax for more detail.\n\
5634 \n\
5635 Redacted form: plszax(digmax, digits)\n\
5636 \n\
5637 This function is used in example 31.\n\
5638 \n\
5639 \n\
5640 \n\
5641 SYNOPSIS:\n\
5642 \n\
5643 plszax(digmax, digits)\n\
5644 \n\
5645 ARGUMENTS:\n\
5646 \n\
5647 digmax (PLINT, input) : Variable to set the maximum number of\n\
5648 digits for the z axis. If nonzero, the printed label will be\n\
5649 switched to a floating-point representation when the number of\n\
5650 digits exceeds digmax.\n\
5651 \n\
5652 digits (PLINT, input) : Field digits value. Currently, changing\n\
5653 its value here has no effect since it is set only by plbox or\n\
5654 plbox3. However, the user may obtain its value after a call to\n\
5655 either of these functions by calling plgzax.\n\
5656 ";
5657 static const char* _wrap_plsurf3dl_texinfo = "-*- texinfo -*-\n\
5658 Plot shaded 3-d surface plot for z[x][y] with y index limits\n\
5659 \n\
5660 DESCRIPTION:\n\
5661 \n\
5662 This variant of plsurf3d (see that function\'s documentation for more\n\
5663 details) should be suitable for the case where the area of the x, y\n\
5664 coordinate grid where z is defined can be non-rectangular. The limits\n\
5665 of that grid are provided by the parameters indexxmin, indexxmax,\n\
5666 indexymin, and indexymax.\n\
5667 \n\
5668 Redacted form: plsurf3dl(x, y, z, opt, clevel, indexxmin, indexymin,\n\
5669 indexymax)\n\
5670 \n\
5671 This function is used in example 8.\n\
5672 \n\
5673 \n\
5674 \n\
5675 SYNOPSIS:\n\
5676 \n\
5677 plsurf3dl(x, y, z, nx, ny, opt, clevel, nlevel, indexxmin, indexxmax, indexymin, indexymax)\n\
5678 \n\
5679 ARGUMENTS:\n\
5680 \n\
5681 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5682 which the function is evaluated.\n\
5683 \n\
5684 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5685 which the function is evaluated.\n\
5686 \n\
5687 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5688 plot. Should have dimensions of\n\
5689 nx by\n\
5690 ny.\n\
5691 \n\
5692 nx (PLINT, input) : Number of x values at which function is\n\
5693 evaluated.\n\
5694 \n\
5695 ny (PLINT, input) : Number of y values at which function is\n\
5696 evaluated.\n\
5697 \n\
5698 opt (PLINT, input) : Determines the way in which the surface is\n\
5699 represented. To specify more than one option just add the options,\n\
5700 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
5701 connecting points at which function is defined.\n\
5702 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
5703 using parameters\n\
5704 nlevel and\n\
5705 clevel.\n\
5706 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
5707 using parameters\n\
5708 nlevel and\n\
5709 clevel.\n\
5710 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
5711 the borders of the plotted function.\n\
5712 opt=MAG_COLOR : the surface is colored according to the value\n\
5713 of Z; if MAG_COLOR is not used, then the surface is colored\n\
5714 according to the intensity of the reflected light in the\n\
5715 surface from a light source whose position is set using\n\
5716 pllightsource.\n\
5717 \n\
5718 \n\
5719 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
5720 levels.\n\
5721 \n\
5722 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
5723 \n\
5724 indexxmin (PLINT, input) : The index value (which must be ≥ 0) that\n\
5725 corresponds to the first x index where z is defined.\n\
5726 \n\
5727 indexxmax (PLINT, input) : The index value (which must be ≤ nx)\n\
5728 which corresponds (by convention) to one more than the last x\n\
5729 index value where z is defined.\n\
5730 \n\
5731 indexymin (PLINT_VECTOR, input) : A vector containing the y index\n\
5732 values which all must be ≥ 0. These values are the first y index\n\
5733 where z is defined for a particular x index in the range from\n\
5734 indexxmin to indexxmax - 1. The dimension of indexymin is\n\
5735 indexxmax.\n\
5736 \n\
5737 indexymax (PLINT_VECTOR, input) : A vector containing the y index\n\
5738 values which all must be ≤ ny. These values correspond (by\n\
5739 convention) to one more than the last y index where z is defined\n\
5740 for a particular x index in the range from indexxmin to indexxmax\n\
5741 - 1. The dimension of indexymax is indexxmax.\n\
5742 ";
5743 static const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
5744 Set font\n\
5745 \n\
5746 DESCRIPTION:\n\
5747 \n\
5748 Sets the font used for subsequent text and symbols. For devices that\n\
5749 still use Hershey fonts this routine has no effect unless the Hershey\n\
5750 fonts with extended character set are loaded (see plfontld). For\n\
5751 unicode-aware devices that use system fonts instead of Hershey fonts,\n\
5752 this routine calls the plsfci routine with argument set up\n\
5753 appropriately for the various cases below. However, this method of\n\
5754 specifying the font for unicode-aware devices is deprecated, and the\n\
5755 much more flexible method of calling plsfont directly is recommended\n\
5756 instead (where plsfont provides a user-friendly interface to plsfci),\n\
5757 \n\
5758 Redacted form: plfont(ifont)\n\
5759 \n\
5760 This function is used in examples 1, 2, 4, 7, 13, 24, and 26.\n\
5761 \n\
5762 \n\
5763 \n\
5764 SYNOPSIS:\n\
5765 \n\
5766 plfont(ifont)\n\
5767 \n\
5768 ARGUMENTS:\n\
5769 \n\
5770 ifont (PLINT, input) : Specifies the font: 1: Sans serif font\n\
5771 (simplest and fastest)\n\
5772 2: Serif font\n\
5773 3: Italic font\n\
5774 4: Script font\n\
5775 ";
5776 static const char* _wrap_plgcmap1_range_texinfo = "-*- texinfo -*-\n\
5777 Get the cmap1 argument range for continuous color plots\n\
5778 \n\
5779 DESCRIPTION:\n\
5780 \n\
5781 Get the cmap1 argument range for continuous color plots. (Use\n\
5782 plscmap1_range to set the cmap1 argument range.)\n\
5783 \n\
5784 Redacted form: plgcmap1_range(min_color, max_color)\n\
5785 \n\
5786 This function is currently not used in any example.\n\
5787 \n\
5788 \n\
5789 \n\
5790 SYNOPSIS:\n\
5791 \n\
5792 plgcmap1_range(min_color, max_color)\n\
5793 \n\
5794 ARGUMENTS:\n\
5795 \n\
5796 min_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5797 minimum cmap1 argument.\n\
5798 \n\
5799 max_color (PLFLT_NC_SCALAR, output) : Returned value of the current\n\
5800 maximum cmap1 argument.\n\
5801 ";
5802 static const char* _wrap_plscmap1_range_texinfo = "-*- texinfo -*-\n\
5803 Set the cmap1 argument range for continuous color plots\n\
5804 \n\
5805 DESCRIPTION:\n\
5806 \n\
5807 Set the cmap1 argument range for continuous color plots that\n\
5808 corresponds to the range of data values. The maximum range\n\
5809 corresponding to the entire cmap1 palette is 0.0-1.0, and the smaller\n\
5810 the cmap1 argument range that is specified with this routine, the\n\
5811 smaller the subset of the cmap1 color palette that is used to\n\
5812 represent the continuous data being plotted. If\n\
5813 min_color is greater than\n\
5814 max_color or\n\
5815 max_color is greater than 1.0 or\n\
5816 min_color is less than 0.0 then no change is made to the cmap1\n\
5817 argument range. (Use plgcmap1_range to get the cmap1 argument range.)\n\
5818 \n\
5819 Redacted form: plscmap1_range(min_color, max_color)\n\
5820 \n\
5821 This function is currently used in example 33.\n\
5822 \n\
5823 \n\
5824 \n\
5825 SYNOPSIS:\n\
5826 \n\
5827 plscmap1_range(min_color, max_color)\n\
5828 \n\
5829 ARGUMENTS:\n\
5830 \n\
5831 min_color (PLFLT, input) : The minimum cmap1 argument. If less\n\
5832 than 0.0, then 0.0 is used instead.\n\
5833 \n\
5834 max_color (PLFLT, input) : The maximum cmap1 argument. If greater\n\
5835 than 1.0, then 1.0 is used instead.\n\
5836 ";
5837 static const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
5838 Draw a circular or elliptical arc\n\
5839 \n\
5840 DESCRIPTION:\n\
5841 \n\
5842 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
5843 semiminor axis b, starting at angle1 and ending at angle2.\n\
5844 \n\
5845 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
5846 fill)\n\
5847 \n\
5848 \n\
5849 This function is used in examples 3 and 27.\n\
5850 \n\
5851 \n\
5852 \n\
5853 SYNOPSIS:\n\
5854 \n\
5855 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
5856 \n\
5857 ARGUMENTS:\n\
5858 \n\
5859 x (PLFLT, input) : X coordinate of arc center.\n\
5860 \n\
5861 y (PLFLT, input) : Y coordinate of arc center.\n\
5862 \n\
5863 a (PLFLT, input) : Length of the semimajor axis of the arc.\n\
5864 \n\
5865 b (PLFLT, input) : Length of the semiminor axis of the arc.\n\
5866 \n\
5867 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
5868 semimajor axis.\n\
5869 \n\
5870 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
5871 semimajor axis.\n\
5872 \n\
5873 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
5874 X-axis.\n\
5875 \n\
5876 fill (PLBOOL, input) : Draw a filled arc.\n\
5877 ";
5878 static const char* _wrap_plot3d_texinfo = "-*- texinfo -*-\n\
5879 Plot 3-d surface plot\n\
5880 \n\
5881 DESCRIPTION:\n\
5882 \n\
5883 Plots a three-dimensional surface plot within the environment set up\n\
5884 by plw3d. The surface is defined by the matrix z[\n\
5885 nx][\n\
5886 ny] , the point z[i][j] being the value of the function at (\n\
5887 x[i],\n\
5888 y[j]). Note that the points in vectors x and y do not need to be\n\
5889 equally spaced, but must be stored in ascending order. The parameter\n\
5890 opt controls the way in which the surface is displayed. For further\n\
5891 details see the PLplot documentation. The only difference between\n\
5892 plmesh and plot3d is that plmesh draws the bottom side of the surface,\n\
5893 while plot3d only draws the surface as viewed from the top.\n\
5894 \n\
5895 Redacted form: plot3d(x, y, z, opt, side)\n\
5896 \n\
5897 This function is used in examples 11 and 21.\n\
5898 \n\
5899 \n\
5900 \n\
5901 SYNOPSIS:\n\
5902 \n\
5903 plot3d(x, y, z, nx, ny, opt, side)\n\
5904 \n\
5905 ARGUMENTS:\n\
5906 \n\
5907 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
5908 which the function is evaluated.\n\
5909 \n\
5910 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
5911 which the function is evaluated.\n\
5912 \n\
5913 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
5914 plot. Should have dimensions of\n\
5915 nx by\n\
5916 ny.\n\
5917 \n\
5918 nx (PLINT, input) : Number of x values at which function is\n\
5919 evaluated.\n\
5920 \n\
5921 ny (PLINT, input) : Number of y values at which function is\n\
5922 evaluated.\n\
5923 \n\
5924 opt (PLINT, input) : Determines the way in which the surface is\n\
5925 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
5926 function of x for each value of y[j] .\n\
5927 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
5928 for each value of x[i] .\n\
5929 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
5930 at which function is defined.\n\
5931 \n\
5932 \n\
5933 side (PLBOOL, input) : Flag to indicate whether or not ``sides\'\'\n\
5934 should be draw on the figure. If side is true sides are drawn,\n\
5935 otherwise no sides are drawn.\n\
5936 ";
5937 static const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
5938 Set area line fill pattern\n\
5939 \n\
5940 DESCRIPTION:\n\
5941 \n\
5942 Sets the area line fill pattern to be used, e.g., for calls to plfill.\n\
5943 The pattern consists of 1 or 2 sets of parallel lines with specified\n\
5944 inclinations and spacings. The arguments to this routine are the\n\
5945 number of sets to use (1 or 2) followed by two vectors (with 1 or 2\n\
5946 elements) specifying the inclinations in tenths of a degree and the\n\
5947 spacing in micrometers. (See also plpsty)\n\
5948 \n\
5949 Redacted form: General: plpat(inc, del)\n\
5950 \n\
5951 \n\
5952 This function is used in example 15.\n\
5953 \n\
5954 \n\
5955 \n\
5956 SYNOPSIS:\n\
5957 \n\
5958 plpat(nlin, inc, del)\n\
5959 \n\
5960 ARGUMENTS:\n\
5961 \n\
5962 nlin (PLINT, input) : Number of sets of lines making up the\n\
5963 pattern, either 1 or 2.\n\
5964 \n\
5965 inc (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5966 inclination in tenths of a degree. (Should be between -900 and\n\
5967 900).\n\
5968 \n\
5969 del (PLINT_VECTOR, input) : A vector containing nlin values of the\n\
5970 spacing in micrometers between the lines making up the pattern.\n\
5971 ";
5972 static const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
5973 Get x axis parameters\n\
5974 \n\
5975 DESCRIPTION:\n\
5976 \n\
5977 Returns current values of the p_digmax and p_digits flags for the x\n\
5978 axis. p_digits is updated after the plot is drawn, so this routine\n\
5979 should only be called after the call to plbox (or plbox3) is complete.\n\
5980 See the PLplot documentation for more information.\n\
5981 \n\
5982 Redacted form: plgxax(p_digmax, p_digits)\n\
5983 \n\
5984 This function is used in example 31.\n\
5985 \n\
5986 \n\
5987 \n\
5988 SYNOPSIS:\n\
5989 \n\
5990 plgxax(p_digmax, p_digits)\n\
5991 \n\
5992 ARGUMENTS:\n\
5993 \n\
5994 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
5995 number of digits for the x axis. If nonzero, the printed label\n\
5996 has been switched to a floating-point representation when the\n\
5997 number of digits exceeds this value.\n\
5998 \n\
5999 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
6000 number of digits for the numeric labels (x axis) from the last\n\
6001 plot.\n\
6002 ";
6003 static const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
6004 Draw filled polygon in 3D\n\
6005 \n\
6006 DESCRIPTION:\n\
6007 \n\
6008 Fills the 3D polygon defined by the n points in the x, y, and z\n\
6009 vectors using the pattern defined by plpsty or plpat. The routine\n\
6010 will automatically close the polygon between the last and first\n\
6011 vertices. If multiple closed polygons are passed in x, y, and z then\n\
6012 plfill3 will fill in between them.\n\
6013 \n\
6014 Redacted form: General: plfill3(x, y, z)\n\
6015 \n\
6016 \n\
6017 This function is used in example 15.\n\
6018 \n\
6019 \n\
6020 \n\
6021 SYNOPSIS:\n\
6022 \n\
6023 plfill3(n, x, y, z)\n\
6024 \n\
6025 ARGUMENTS:\n\
6026 \n\
6027 n (PLINT, input) : Number of vertices in polygon.\n\
6028 \n\
6029 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6030 vertices.\n\
6031 \n\
6032 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6033 vertices.\n\
6034 \n\
6035 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6036 vertices.\n\
6037 ";
6038 static const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
6039 Set color, cmap0\n\
6040 \n\
6041 DESCRIPTION:\n\
6042 \n\
6043 Sets the color index for cmap0 (see the PLplot documentation).\n\
6044 \n\
6045 Redacted form: plcol0(icol0)\n\
6046 \n\
6047 This function is used in examples 1-9, 11-16, 18-27, and 29.\n\
6048 \n\
6049 \n\
6050 \n\
6051 SYNOPSIS:\n\
6052 \n\
6053 plcol0(icol0)\n\
6054 \n\
6055 ARGUMENTS:\n\
6056 \n\
6057 icol0 (PLINT, input) : Integer representing the color. The\n\
6058 defaults at present are (these may change):\n\
6059 0 black (default background)\n\
6060 1 red (default foreground)\n\
6061 2 yellow\n\
6062 3 green\n\
6063 4 aquamarine\n\
6064 5 pink\n\
6065 6 wheat\n\
6066 7 grey\n\
6067 8 brown\n\
6068 9 blue\n\
6069 10 BlueViolet\n\
6070 11 cyan\n\
6071 12 turquoise\n\
6072 13 magenta\n\
6073 14 salmon\n\
6074 15 white\n\
6075 \n\
6076 Use plscmap0 to change the entire cmap0 color palette and plscol0 to\n\
6077 change an individual color in the cmap0 color palette.\n\
6078 ";
6079 static const char* _wrap_plmaptex_texinfo = "-*- texinfo -*-\n\
6080 Draw text at points defined by Shapefile data in world coordinates\n\
6081 \n\
6082 DESCRIPTION:\n\
6083 \n\
6084 As per plmapline, however the items are plotted as text in the same\n\
6085 way as plptex.\n\
6086 \n\
6087 Redacted form: plmaptex(mapform, name, dx, dy, just, text, minx, maxx,\n\
6088 miny, maxy, plotentry)\n\
6089 \n\
6090 This function is used in example 19.\n\
6091 \n\
6092 \n\
6093 \n\
6094 SYNOPSIS:\n\
6095 \n\
6096 plmaptex(mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry)\n\
6097 \n\
6098 ARGUMENTS:\n\
6099 \n\
6100 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6101 transform the coordinates given in the shapefile into a plot\n\
6102 coordinate system. By using this transform, we can change from a\n\
6103 longitude, latitude coordinate to a polar stereographic project,\n\
6104 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6105 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6106 mapform(), x[] and y[] should be replaced by the corresponding\n\
6107 plot coordinates. If no transform is desired, mapform can be\n\
6108 replaced by NULL.\n\
6109 \n\
6110 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6111 the file name of a set of Shapefile files without the file\n\
6112 extension.\n\
6113 \n\
6114 dx (PLFLT, input) : Used to define the slope of the texts which is\n\
6115 dy/dx.\n\
6116 \n\
6117 dy (PLFLT, input) : Used to define the slope of the texts which is\n\
6118 dy/dx.\n\
6119 \n\
6120 just (PLFLT, input) : Set the justification of the text. The value\n\
6121 given will be the fraction of the distance along the string that\n\
6122 sits at the given point. 0.0 gives left aligned text, 0.5 gives\n\
6123 centralized text and 1.0 gives right aligned text.\n\
6124 \n\
6125 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be drawn.\n\
6126 \n\
6127 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6128 be in the same units as used by the Shapefile. You could use a\n\
6129 very large negative number to plot everything, but you can improve\n\
6130 performance by limiting the area drawn. The units must match those\n\
6131 of the Shapefile projection, which may be for example longitude or\n\
6132 distance. The value of minx must be less than the value of maxx.\n\
6133 \n\
6134 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6135 use a very large number to plot everything, but you can improve\n\
6136 performance by limiting the area drawn.\n\
6137 \n\
6138 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6139 be in the same units as used by the Shapefile. You could use a\n\
6140 very large negative number to plot everything, but you can improve\n\
6141 performance by limiting the area drawn. The units must match those\n\
6142 of the Shapefile projection, which may be for example latitude or\n\
6143 distance. The value of miny must be less than the value of maxy.\n\
6144 \n\
6145 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6146 use a very large number to plot everything, but you can improve\n\
6147 performance by limiting the area drawn.\n\
6148 \n\
6149 plotentry (PLINT, input) : An integer indicating which text string\n\
6150 of the Shapefile (zero indexed) will be drawn.\n\
6151 ";
6152 static const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
6153 Draw a line between two points\n\
6154 \n\
6155 DESCRIPTION:\n\
6156 \n\
6157 Joins the point (\n\
6158 x1,\n\
6159 y1) to (\n\
6160 x2,\n\
6161 y2).\n\
6162 \n\
6163 Redacted form: pljoin(x1,y1,x2,y2)\n\
6164 \n\
6165 This function is used in examples 3 and 14.\n\
6166 \n\
6167 \n\
6168 \n\
6169 SYNOPSIS:\n\
6170 \n\
6171 pljoin(x1, y1, x2, y2)\n\
6172 \n\
6173 ARGUMENTS:\n\
6174 \n\
6175 x1 (PLFLT, input) : x coordinate of first point.\n\
6176 \n\
6177 y1 (PLFLT, input) : y coordinate of first point.\n\
6178 \n\
6179 x2 (PLFLT, input) : x coordinate of second point.\n\
6180 \n\
6181 y2 (PLFLT, input) : y coordinate of second point.\n\
6182 ";
6183 static const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
6184 Set color, cmap1\n\
6185 \n\
6186 DESCRIPTION:\n\
6187 \n\
6188 Sets the color for cmap1 (see the PLplot documentation).\n\
6189 \n\
6190 Redacted form: plcol1(col1)\n\
6191 \n\
6192 This function is used in examples 12 and 21.\n\
6193 \n\
6194 \n\
6195 \n\
6196 SYNOPSIS:\n\
6197 \n\
6198 plcol1(col1)\n\
6199 \n\
6200 ARGUMENTS:\n\
6201 \n\
6202 col1 (PLFLT, input) : This value must be in the range (0.0-1.0) and\n\
6203 is mapped to color using the continuous cmap1 palette which by\n\
6204 default ranges from blue to the background color to red. The\n\
6205 cmap1 palette can also be straightforwardly changed by the user\n\
6206 with plscmap1 or plscmap1l.\n\
6207 ";
6208 static const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
6209 Set orientation\n\
6210 \n\
6211 DESCRIPTION:\n\
6212 \n\
6213 Set integer plot orientation parameter. This function is identical to\n\
6214 plsdiori except for the type of the argument, and should be used in\n\
6215 the same way. See the documentation of plsdiori for details.\n\
6216 \n\
6217 Redacted form: plsori(ori)\n\
6218 \n\
6219 This function is used in example 3.\n\
6220 \n\
6221 \n\
6222 \n\
6223 SYNOPSIS:\n\
6224 \n\
6225 plsori(ori)\n\
6226 \n\
6227 ARGUMENTS:\n\
6228 \n\
6229 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
6230 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
6231 angle.\n\
6232 ";
6233 static const char* _wrap_plctime_texinfo = "-*- texinfo -*-\n\
6234 Calculate continuous time from broken-down time for the current stream\n\
6235 \n\
6236 DESCRIPTION:\n\
6237 \n\
6238 Calculate continuous time, ctime, from broken-down time for the\n\
6239 current stream. The broken-down\n\
6240 time is specified by the following parameters: year, month, day, hour,\n\
6241 min, and sec. This function is the inverse of plbtime.\n\
6242 \n\
6243 The PLplot definition of broken-down time is a calendar time that\n\
6244 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6245 responsibility to apply those offsets (if so desired) before using the\n\
6246 PLplot time API. By default broken-down time is defined using the\n\
6247 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6248 continuous time is defined as the number of seconds since the Unix\n\
6249 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6250 broken-down and continuous time are possible, see plconfigtime which\n\
6251 specifies that transformation for the current stream.\n\
6252 \n\
6253 Redacted form: General: plctime(year, month, day, hour, min, sec,\n\
6254 ctime)\n\
6255 \n\
6256 \n\
6257 This function is used in example 29.\n\
6258 \n\
6259 \n\
6260 \n\
6261 SYNOPSIS:\n\
6262 \n\
6263 plctime(year, month, day, hour, min, sec, ctime)\n\
6264 \n\
6265 ARGUMENTS:\n\
6266 \n\
6267 year (PLINT, input) : Input year.\n\
6268 \n\
6269 month (PLINT, input) : Input month in range from 0 (January) to 11\n\
6270 (December).\n\
6271 \n\
6272 day (PLINT, input) : Input day in range from 1 to 31.\n\
6273 \n\
6274 hour (PLINT, input) : Input hour in range from 0 to 23\n\
6275 \n\
6276 min (PLINT, input) : Input minute in range from 0 to 59.\n\
6277 \n\
6278 sec (PLFLT, input) : Input second in range from 0. to 60.\n\
6279 \n\
6280 ctime (PLFLT_NC_SCALAR, output) : Returned value of the continuous\n\
6281 time calculated from the broken-down time specified by the\n\
6282 previous parameters.\n\
6283 ";
6284 static const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
6285 Plot continental outline or shapefile data in world coordinates\n\
6286 \n\
6287 DESCRIPTION:\n\
6288 \n\
6289 Plots continental outlines or shapefile data in world coordinates. A\n\
6290 demonstration of how to use this function to create different\n\
6291 projections can be found in examples/c/x19c. PLplot is provided with\n\
6292 basic coastal outlines and USA state borders. To use the map\n\
6293 functionality PLplot must be compiled with the shapelib library.\n\
6294 Shapefiles have become a popular standard for geographical data and\n\
6295 data in this format can be easily found from a number of online\n\
6296 sources. Shapefile data is actually provided as three or more files\n\
6297 with the same filename, but different extensions. The .shp and .shx\n\
6298 files are required for plotting Shapefile data with PLplot.\n\
6299 \n\
6300 PLplot currently supports the point, multipoint, polyline and polygon\n\
6301 objects within shapefiles. However holes in polygons are not\n\
6302 supported. When plmap is used the type of object is derived from the\n\
6303 shapefile, if you wish to override the type then use one of the other\n\
6304 plmap variants. The built in maps have line data only.\n\
6305 \n\
6306 Redacted form: plmap(mapform, name, minx, maxx, miny, maxy)\n\
6307 \n\
6308 This function is used in example 19.\n\
6309 \n\
6310 \n\
6311 \n\
6312 SYNOPSIS:\n\
6313 \n\
6314 plmap(mapform, name, minx, maxx, miny, maxy)\n\
6315 \n\
6316 ARGUMENTS:\n\
6317 \n\
6318 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6319 transform the original map data coordinates to a new coordinate\n\
6320 system. The PLplot-supplied map data is provided as latitudes and\n\
6321 longitudes; other Shapefile data may be provided in other\n\
6322 coordinate systems as can be found in their .prj plain text files.\n\
6323 For example, by using this transform we can change from a\n\
6324 longitude, latitude coordinate to a polar stereographic\n\
6325 projection. Initially, x[0]..[n-1] are the original x coordinates\n\
6326 (longitudes for the PLplot-supplied data) and y[0]..y[n-1] are the\n\
6327 corresponding y coordinates (latitudes for the PLplot supplied\n\
6328 data). After the call to mapform(), x[] and y[] should be\n\
6329 replaced by the corresponding plot coordinates. If no transform is\n\
6330 desired, mapform can be replaced by NULL.\n\
6331 \n\
6332 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6333 the type of map plotted. This is either one of the PLplot built-in\n\
6334 maps or the file name of a set of Shapefile files without the file\n\
6335 extensions. For the PLplot built-in maps the possible values are:\n\
6336 \"globe\" -- continental outlines\n\
6337 \"usa\" -- USA and state boundaries\n\
6338 \"cglobe\" -- continental outlines and countries\n\
6339 \"usaglobe\" -- USA, state boundaries and continental outlines\n\
6340 \n\
6341 \n\
6342 minx (PLFLT, input) : The minimum x value of map elements to be\n\
6343 drawn. The units must match the shapefile (built in maps are\n\
6344 degrees lat/lon). Objects in the file which do not encroach on the\n\
6345 box defined by minx, maxx, miny, maxy will not be rendered. But\n\
6346 note this is simply an optimisation, not a clipping so for objects\n\
6347 with some points inside the box and some points outside the box\n\
6348 all the points will be rendered. These parameters also define\n\
6349 latitude and longitude wrapping for shapefiles using these units.\n\
6350 Longitude points will be wrapped by integer multiples of 360\n\
6351 degrees to place them in the box. This allows the same data to be\n\
6352 used on plots from -180-180 or 0-360 longitude ranges. In fact if\n\
6353 you plot from -180-540 you will get two cycles of data drawn. The\n\
6354 value of minx must be less than the value of maxx. Passing in a\n\
6355 nan, max/-max floating point number or +/-infinity will case the\n\
6356 bounding box from the shapefile to be used.\n\
6357 \n\
6358 maxx (PLFLT, input) : The maximum x value of map elements to be\n\
6359 drawn - see minx.\n\
6360 \n\
6361 miny (PLFLT, input) : The minimum y value of map elements to be\n\
6362 drawn - see minx.\n\
6363 \n\
6364 maxy (PLFLT, input) : The maximum y value of map elements to be\n\
6365 drawn - see minx.\n\
6366 ";
6367 static const char* _wrap_plbtime_texinfo = "-*- texinfo -*-\n\
6368 Calculate broken-down time from continuous time for the current stream\n\
6369 \n\
6370 DESCRIPTION:\n\
6371 \n\
6372 Calculate broken-down time; year, month, day, hour, min, sec; from\n\
6373 continuous time, ctime for the current stream. This function is the\n\
6374 inverse of plctime.\n\
6375 \n\
6376 The PLplot definition of broken-down time is a calendar time that\n\
6377 completely ignores all time zone offsets, i.e., it is the user\'s\n\
6378 responsibility to apply those offsets (if so desired) before using the\n\
6379 PLplot time API. By default broken-down time is defined using the\n\
6380 proleptic Gregorian calendar without the insertion of leap seconds and\n\
6381 continuous time is defined as the number of seconds since the Unix\n\
6382 epoch of 1970-01-01T00:00:00Z. However, other definitions of\n\
6383 broken-down and continuous time are possible, see plconfigtime.\n\
6384 \n\
6385 Redacted form: General: plbtime(year, month, day, hour, min, sec,\n\
6386 ctime)\n\
6387 \n\
6388 \n\
6389 This function is used in example 29.\n\
6390 \n\
6391 \n\
6392 \n\
6393 SYNOPSIS:\n\
6394 \n\
6395 plbtime(year, month, day, hour, min, sec, ctime)\n\
6396 \n\
6397 ARGUMENTS:\n\
6398 \n\
6399 year (PLINT_NC_SCALAR, output) : Returned value of years with\n\
6400 positive values corresponding to CE (i.e., 1 = 1 CE, etc.) and\n\
6401 non-negative values corresponding to BCE (e.g., 0 = 1 BCE, -1 = 2\n\
6402 BCE, etc.)\n\
6403 \n\
6404 month (PLINT_NC_SCALAR, output) : Returned value of month within\n\
6405 the year in the range from 0 (January) to 11 (December).\n\
6406 \n\
6407 day (PLINT_NC_SCALAR, output) : Returned value of day within the\n\
6408 month in the range from 1 to 31.\n\
6409 \n\
6410 hour (PLINT_NC_SCALAR, output) : Returned value of hour within the\n\
6411 day in the range from 0 to 23.\n\
6412 \n\
6413 min (PLINT_NC_SCALAR, output) : Returned value of minute within the\n\
6414 hour in the range from 0 to 59\n\
6415 \n\
6416 sec (PLFLT_NC_SCALAR, output) : Returned value of second within the\n\
6417 minute in range from 0. to 60.\n\
6418 \n\
6419 ctime (PLFLT, input) : Continuous time from which the broken-down\n\
6420 time is calculated.\n\
6421 ";
6422 static const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
6423 Get current stream number\n\
6424 \n\
6425 DESCRIPTION:\n\
6426 \n\
6427 Gets the number of the current output stream. See also plsstrm.\n\
6428 \n\
6429 Redacted form: plgstrm(p_strm)\n\
6430 \n\
6431 This function is used in example 1,20.\n\
6432 \n\
6433 \n\
6434 \n\
6435 SYNOPSIS:\n\
6436 \n\
6437 plgstrm(p_strm)\n\
6438 \n\
6439 ARGUMENTS:\n\
6440 \n\
6441 p_strm (PLINT_NC_SCALAR, output) : Returned value of the current\n\
6442 stream value.\n\
6443 ";
6444 static const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
6445 Draw a line in 3 space\n\
6446 \n\
6447 DESCRIPTION:\n\
6448 \n\
6449 Draws line in 3 space defined by n points in x, y, and z. You must\n\
6450 first set up the viewport, the 2d viewing window (in world\n\
6451 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
6452 more info.\n\
6453 \n\
6454 Redacted form: plline3(x, y, z)\n\
6455 \n\
6456 This function is used in example 18.\n\
6457 \n\
6458 \n\
6459 \n\
6460 SYNOPSIS:\n\
6461 \n\
6462 plline3(n, x, y, z)\n\
6463 \n\
6464 ARGUMENTS:\n\
6465 \n\
6466 n (PLINT, input) : Number of points defining line.\n\
6467 \n\
6468 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
6469 points.\n\
6470 \n\
6471 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
6472 points.\n\
6473 \n\
6474 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
6475 points.\n\
6476 ";
6477 static const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
6478 Load Hershey fonts\n\
6479 \n\
6480 DESCRIPTION:\n\
6481 \n\
6482 Loads the Hershey fonts used for text and symbols. This routine may\n\
6483 be called before or after initializing PLplot. If not explicitly\n\
6484 called before PLplot initialization, then by default that\n\
6485 initialization loads Hershey fonts with the extended character set.\n\
6486 This routine only has a practical effect for devices that still use\n\
6487 Hershey fonts (as opposed to modern devices that use unicode-aware\n\
6488 system fonts instead of Hershey fonts).\n\
6489 \n\
6490 Redacted form: plfontld(fnt)\n\
6491 \n\
6492 This function is used in examples 1 and 7.\n\
6493 \n\
6494 \n\
6495 \n\
6496 SYNOPSIS:\n\
6497 \n\
6498 plfontld(fnt)\n\
6499 \n\
6500 ARGUMENTS:\n\
6501 \n\
6502 fnt (PLINT, input) : Specifies the type of Hershey fonts to load.\n\
6503 A zero value specifies Hershey fonts with the standard character\n\
6504 set and a non-zero value (the default assumed if plfontld is never\n\
6505 called) specifies Hershey fonts with the extended character set.\n\
6506 ";
6507 static const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
6508 Set any command-line option\n\
6509 \n\
6510 DESCRIPTION:\n\
6511 \n\
6512 Set any command-line option internally from a program before it\n\
6513 invokes plinit. opt is the name of the command-line option and optarg\n\
6514 is the corresponding command-line option argument.\n\
6515 \n\
6516 This function returns 0 on success.\n\
6517 \n\
6518 Redacted form: plsetopt(opt, optarg)\n\
6519 \n\
6520 This function is used in example 14.\n\
6521 \n\
6522 \n\
6523 \n\
6524 SYNOPSIS:\n\
6525 \n\
6526 PLINT plsetopt(opt, optarg)\n\
6527 \n\
6528 ARGUMENTS:\n\
6529 \n\
6530 opt (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6531 the command-line option.\n\
6532 \n\
6533 optarg (PLCHAR_VECTOR, input) : An ascii character string\n\
6534 containing the argument of the command-line option.\n\
6535 ";
6536 static const char* _wrap_plmapline_texinfo = "-*- texinfo -*-\n\
6537 Plot all or a subset of Shapefile data using lines in world coordinates\n\
6538 \n\
6539 DESCRIPTION:\n\
6540 \n\
6541 Plot all or a subset of Shapefile data using lines in world\n\
6542 coordinates. Our 19th standard example demonstrates how to use this\n\
6543 function. This function plots data from a Shapefile using lines as in\n\
6544 plmap, however it also has the option of also only drawing specified\n\
6545 elements from the Shapefile. The vector of indices of the required\n\
6546 elements are passed as a function argument. The Shapefile data should\n\
6547 include a metadata file (extension.dbf) listing all items within the\n\
6548 Shapefile. This file can be opened by most popular spreadsheet\n\
6549 programs and can be used to decide which indices to pass to this\n\
6550 function.\n\
6551 \n\
6552 Redacted form: plmapline(mapform, name, minx, maxx, miny, maxy,\n\
6553 plotentries)\n\
6554 \n\
6555 This function is used in example 19.\n\
6556 \n\
6557 \n\
6558 \n\
6559 SYNOPSIS:\n\
6560 \n\
6561 plmapline(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
6562 \n\
6563 ARGUMENTS:\n\
6564 \n\
6565 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
6566 transform the coordinates given in the shapefile into a plot\n\
6567 coordinate system. By using this transform, we can change from a\n\
6568 longitude, latitude coordinate to a polar stereographic project,\n\
6569 for example. Initially, x[0]..[n-1] are the longitudes and\n\
6570 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
6571 mapform(), x[] and y[] should be replaced by the corresponding\n\
6572 plot coordinates. If no transform is desired, mapform can be\n\
6573 replaced by NULL.\n\
6574 \n\
6575 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
6576 the file name of a set of Shapefile files without the file\n\
6577 extension.\n\
6578 \n\
6579 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
6580 be in the same units as used by the Shapefile. You could use a\n\
6581 very large negative number to plot everything, but you can improve\n\
6582 performance by limiting the area drawn. The units must match those\n\
6583 of the Shapefile projection, which may be for example longitude or\n\
6584 distance. The value of minx must be less than the value of maxx.\n\
6585 \n\
6586 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
6587 use a very large number to plot everything, but you can improve\n\
6588 performance by limiting the area drawn.\n\
6589 \n\
6590 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
6591 be in the same units as used by the Shapefile. You could use a\n\
6592 very large negative number to plot everything, but you can improve\n\
6593 performance by limiting the area drawn. The units must match those\n\
6594 of the Shapefile projection, which may be for example latitude or\n\
6595 distance. The value of miny must be less than the value of maxy.\n\
6596 \n\
6597 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
6598 use a very large number to plot everything, but you can improve\n\
6599 performance by limiting the area drawn.\n\
6600 \n\
6601 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
6602 zero-based indices of the Shapefile elements which will be drawn.\n\
6603 Setting\n\
6604 plotentries to NULL will plot all elements of the Shapefile.\n\
6605 \n\
6606 nplotentries (PLINT, input) : The number of items in\n\
6607 plotentries. Ignored if\n\
6608 plotentries is NULL.\n\
6609 ";
6610 static const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
6611 Used to globally turn color output on/off\n\
6612 \n\
6613 DESCRIPTION:\n\
6614 \n\
6615 Used to globally turn color output on/off for those drivers/devices\n\
6616 that support it.\n\
6617 \n\
6618 Redacted form: plscolor(color)\n\
6619 \n\
6620 This function is used in example 31.\n\
6621 \n\
6622 \n\
6623 \n\
6624 SYNOPSIS:\n\
6625 \n\
6626 plscolor(color)\n\
6627 \n\
6628 ARGUMENTS:\n\
6629 \n\
6630 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
6631 turned off. If non-zero, color is turned on.\n\
6632 ";
6633 static const char* _wrap_plGetCursor_texinfo = "-*- texinfo -*-\n\
6634 Wait for graphics input event and translate to world coordinates.\n\
6635 \n\
6636 DESCRIPTION:\n\
6637 \n\
6638 Wait for graphics input event and translate to world coordinates.\n\
6639 Returns 0 if no translation to world coordinates is possible.\n\
6640 \n\
6641 This function returns 1 on success and 0 if no translation to world\n\
6642 coordinates is possible.\n\
6643 \n\
6644 Redacted form: plGetCursor(gin)\n\
6645 \n\
6646 This function is used in examples 1 and 20.\n\
6647 \n\
6648 \n\
6649 \n\
6650 SYNOPSIS:\n\
6651 \n\
6652 PLINT plGetCursor(gin)\n\
6653 \n\
6654 ARGUMENTS:\n\
6655 \n\
6656 gin (PLGraphicsIn *, output) : Pointer to PLGraphicsIn structure\n\
6657 which will contain the output. The structure is not allocated by\n\
6658 the routine and must exist before the function is called.\n\
6659 ";
6660 static const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
6661 Get the current device (keyword) name\n\
6662 \n\
6663 DESCRIPTION:\n\
6664 \n\
6665 Get the current device (keyword) name. Note: you must have allocated\n\
6666 space for this (80 characters is safe).\n\
6667 \n\
6668 Redacted form: plgdev(p_dev)\n\
6669 \n\
6670 This function is used in example 14.\n\
6671 \n\
6672 \n\
6673 \n\
6674 SYNOPSIS:\n\
6675 \n\
6676 plgdev(p_dev)\n\
6677 \n\
6678 ARGUMENTS:\n\
6679 \n\
6680 p_dev (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6681 (with preallocated length of 80 characters or more) containing the\n\
6682 device (keyword) name.\n\
6683 ";
6684 static const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
6685 Add a point to a strip chart\n\
6686 \n\
6687 DESCRIPTION:\n\
6688 \n\
6689 Add a point to a given pen of a given strip chart. There is no need\n\
6690 for all pens to have the same number of points or to be equally\n\
6691 sampled in the x coordinate. Allocates memory and rescales as\n\
6692 necessary.\n\
6693 \n\
6694 Redacted form: plstripa(id, pen, x, y)\n\
6695 \n\
6696 This function is used in example 17.\n\
6697 \n\
6698 \n\
6699 \n\
6700 SYNOPSIS:\n\
6701 \n\
6702 plstripa(id, pen, x, y)\n\
6703 \n\
6704 ARGUMENTS:\n\
6705 \n\
6706 id (PLINT, input) : Identification number of the strip chart (set\n\
6707 up in plstripc).\n\
6708 \n\
6709 pen (PLINT, input) : Pen number (ranges from 0 to 3).\n\
6710 \n\
6711 x (PLFLT, input) : X coordinate of point to plot.\n\
6712 \n\
6713 y (PLFLT, input) : Y coordinate of point to plot.\n\
6714 ";
6715 static const char* _wrap_plstripc_texinfo = "-*- texinfo -*-\n\
6716 Create a 4-pen strip chart\n\
6717 \n\
6718 DESCRIPTION:\n\
6719 \n\
6720 Create a 4-pen strip chart, to be used afterwards by plstripa\n\
6721 \n\
6722 Redacted form: General: plstripc(id, xspec, yspec, xmin, xmax, xjump,\n\
6723 ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline,\n\
6724 styline, legline, labx, laby, labz)\n\
6725 \n\
6726 \n\
6727 This function is used in example 17.\n\
6728 \n\
6729 \n\
6730 \n\
6731 SYNOPSIS:\n\
6732 \n\
6733 plstripc(id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline[], labx, laby, labtop)\n\
6734 \n\
6735 ARGUMENTS:\n\
6736 \n\
6737 id (PLINT_NC_SCALAR, output) : Returned value of the identification\n\
6738 number of the strip chart to use on plstripa and plstripd.\n\
6739 \n\
6740 xspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6741 the x-axis specification as in plbox.\n\
6742 \n\
6743 yspec (PLCHAR_VECTOR, input) : An ascii character string containing\n\
6744 the y-axis specification as in plbox.\n\
6745 \n\
6746 xmin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6747 change as data are added.\n\
6748 \n\
6749 xmax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6750 change as data are added.\n\
6751 \n\
6752 xjump (PLFLT, input) : When x attains xmax, the length of the plot\n\
6753 is multiplied by the factor (1 +\n\
6754 xjump) .\n\
6755 \n\
6756 ymin (PLFLT, input) : Initial coordinates of plot box; they will\n\
6757 change as data are added.\n\
6758 \n\
6759 ymax (PLFLT, input) : Initial coordinates of plot box; they will\n\
6760 change as data are added.\n\
6761 \n\
6762 xlpos (PLFLT, input) : X legend box position (range from 0 to 1).\n\
6763 \n\
6764 ylpos (PLFLT, input) : Y legend box position (range from 0 to 1).\n\
6765 \n\
6766 y_ascl (PLBOOL, input) : Autoscale y between x jumps if y_ascl is\n\
6767 true, otherwise not.\n\
6768 \n\
6769 acc (PLBOOL, input) : Accumulate strip plot if acc is true,\n\
6770 otherwise slide display.\n\
6771 \n\
6772 colbox (PLINT, input) : Plot box color index (cmap0).\n\
6773 \n\
6774 collab (PLINT, input) : Legend color index (cmap0).\n\
6775 \n\
6776 colline (PLINT_VECTOR, input) : A vector containing the cmap0 color\n\
6777 indices for the 4 pens.\n\
6778 \n\
6779 styline (PLINT_VECTOR, input) : A vector containing the line style\n\
6780 indices for the 4 pens.\n\
6781 \n\
6782 legline (PLCHAR_MATRIX, input) : A vector of UTF-8 character\n\
6783 strings containing legends for the 4 pens.\n\
6784 \n\
6785 labx (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6786 the label for the x axis.\n\
6787 \n\
6788 laby (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6789 the label for the y axis.\n\
6790 \n\
6791 labtop (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
6792 the plot title.\n\
6793 ";
6794 static const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
6795 Deletes and releases memory used by a strip chart\n\
6796 \n\
6797 DESCRIPTION:\n\
6798 \n\
6799 Deletes and releases memory used by a strip chart.\n\
6800 \n\
6801 Redacted form: plstripd(id)\n\
6802 \n\
6803 This function is used in example 17.\n\
6804 \n\
6805 \n\
6806 \n\
6807 SYNOPSIS:\n\
6808 \n\
6809 plstripd(id)\n\
6810 \n\
6811 ARGUMENTS:\n\
6812 \n\
6813 id (PLINT, input) : Identification number of strip chart to delete.\n\
6814 ";
6815 static const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
6816 Specify viewport using coordinates and aspect ratio\n\
6817 \n\
6818 DESCRIPTION:\n\
6819 \n\
6820 Device-independent routine for setting up the viewport. The viewport\n\
6821 is chosen to be the largest with the given aspect ratio that fits\n\
6822 within the specified region (in terms of normalized subpage\n\
6823 coordinates). This routine is functionally equivalent to plvpor when\n\
6824 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
6825 routine reserves no extra space at the edges for labels.\n\
6826 \n\
6827 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6828 \n\
6829 This function is used in example 9.\n\
6830 \n\
6831 \n\
6832 \n\
6833 SYNOPSIS:\n\
6834 \n\
6835 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
6836 \n\
6837 ARGUMENTS:\n\
6838 \n\
6839 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
6840 left-hand edge of the viewport.\n\
6841 \n\
6842 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
6843 right-hand edge of the viewport.\n\
6844 \n\
6845 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
6846 bottom edge of the viewport.\n\
6847 \n\
6848 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
6849 edge of the viewport.\n\
6850 \n\
6851 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
6852 axis.\n\
6853 ";
6854 static const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
6855 Assign a function to use for generating custom axis labels\n\
6856 \n\
6857 DESCRIPTION:\n\
6858 \n\
6859 This function allows a user to provide their own function to provide\n\
6860 axis label text. The user function is given the numeric value for a\n\
6861 point on an axis and returns a string label to correspond with that\n\
6862 value. Custom axis labels can be enabled by passing appropriate\n\
6863 arguments to plenv, plbox, plbox3 and similar functions.\n\
6864 \n\
6865 This function is used in example 19.\n\
6866 \n\
6867 \n\
6868 \n\
6869 SYNOPSIS:\n\
6870 \n\
6871 plslabelfunc(label_func, label_data)\n\
6872 \n\
6873 ARGUMENTS:\n\
6874 \n\
6875 label_func (PLLABEL_FUNC_callback, input) : This is the custom\n\
6876 label function. In order to reset to the default labelling, set\n\
6877 this to NULL. The labelling function parameters are, in order:\n\
6878 axis: This indicates which axis a label is being requested for.\n\
6879 The value will be one of PL_X_AXIS, PL_Y_AXIS or PL_Z_AXIS.\n\
6880 \n\
6881 value: This is the value along the axis which is being labelled.\n\
6882 \n\
6883 label_text: The string representation of the label value.\n\
6884 \n\
6885 length: The maximum length in characters allowed for label_text.\n\
6886 \n\
6887 \n\
6888 label_data (PLPointer, input) : This parameter may be used to pass\n\
6889 data to the label_func function.\n\
6890 ";
6891 static const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
6892 Set length of major ticks\n\
6893 \n\
6894 DESCRIPTION:\n\
6895 \n\
6896 This sets up the length of the major ticks. The actual length is the\n\
6897 product of the default length and a scaling factor as for character\n\
6898 height.\n\
6899 \n\
6900 Redacted form: plsmaj(def, scale)\n\
6901 \n\
6902 This function is used in example 29.\n\
6903 \n\
6904 \n\
6905 \n\
6906 SYNOPSIS:\n\
6907 \n\
6908 plsmaj(def, scale)\n\
6909 \n\
6910 ARGUMENTS:\n\
6911 \n\
6912 def (PLFLT, input) : The default length of a major tick in\n\
6913 millimeters, should be set to zero if the default length is to\n\
6914 remain unchanged.\n\
6915 \n\
6916 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
6917 actual tick length.\n\
6918 ";
6919 static const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
6920 Get the current library version number\n\
6921 \n\
6922 DESCRIPTION:\n\
6923 \n\
6924 Get the current library version number. Note: you must have allocated\n\
6925 space for this (80 characters is safe).\n\
6926 \n\
6927 Redacted form: plgver(p_ver)\n\
6928 \n\
6929 This function is used in example 1.\n\
6930 \n\
6931 \n\
6932 \n\
6933 SYNOPSIS:\n\
6934 \n\
6935 plgver(p_ver)\n\
6936 \n\
6937 ARGUMENTS:\n\
6938 \n\
6939 p_ver (PLCHAR_NC_VECTOR, output) : Returned ascii character string\n\
6940 (with preallocated length of 80 characters or more) containing the\n\
6941 PLplot version number.\n\
6942 ";
6943 static const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
6944 Set format of numerical label for contours\n\
6945 \n\
6946 DESCRIPTION:\n\
6947 \n\
6948 Set format of numerical label for contours.\n\
6949 \n\
6950 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
6951 \n\
6952 This function is used example 9.\n\
6953 \n\
6954 \n\
6955 \n\
6956 SYNOPSIS:\n\
6957 \n\
6958 pl_setcontlabelformat(lexp, sigdig)\n\
6959 \n\
6960 ARGUMENTS:\n\
6961 \n\
6962 lexp (PLINT, input) : If the contour numerical label is greater\n\
6963 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
6964 format is used. Default value of lexp is 4.\n\
6965 \n\
6966 sigdig (PLINT, input) : Number of significant digits. Default\n\
6967 value is 2.\n\
6968 ";
6969 static const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
6970 Parse command-line arguments\n\
6971 \n\
6972 DESCRIPTION:\n\
6973 \n\
6974 Parse command-line arguments.\n\
6975 \n\
6976 plparseopts removes all recognized flags (decreasing argc\n\
6977 accordingly), so that invalid input may be readily detected. It can\n\
6978 also be used to process user command line flags. The user can merge\n\
6979 an option table of type PLOptionTable into the internal option table\n\
6980 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
6981 the external table(s) be parsed by calling plClearOpts before\n\
6982 plMergeOpts.\n\
6983 \n\
6984 The default action taken by plparseopts is as follows:\n\
6985 Returns with an error if an unrecognized option or badly formed\n\
6986 option-value pair are encountered.\n\
6987 Returns immediately (return code 0) when the first non-option command\n\
6988 line argument is found.\n\
6989 Returns with the return code of the option handler, if one was called.\n\
6990 \n\
6991 Deletes command line arguments from argv list as they are found, and\n\
6992 decrements argc accordingly.\n\
6993 Does not show \"invisible\" options in usage or help messages.\n\
6994 Assumes the program name is contained in argv[0].\n\
6995 \n\
6996 These behaviors may be controlled through the\n\
6997 mode argument.\n\
6998 \n\
6999 Redacted form: General: plparseopts(argv, mode)\n\
7000 \n\
7001 \n\
7002 This function is used in all of the examples.\n\
7003 \n\
7004 \n\
7005 \n\
7006 SYNOPSIS:\n\
7007 \n\
7008 PLINT plparseopts(p_argc, argv, mode)\n\
7009 \n\
7010 ARGUMENTS:\n\
7011 \n\
7012 p_argc (int *, input/output) : Number of arguments.\n\
7013 \n\
7014 argv (PLCHAR_NC_MATRIX, input/output) : A vector of character\n\
7015 strings containing *p_argc command-line arguments.\n\
7016 \n\
7017 mode (PLINT, input) : Parsing mode with the following\n\
7018 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
7019 and all error messages enabled, including program exit when an\n\
7020 error occurs. Anything on the command line that isn\'t recognized\n\
7021 as a valid option or option argument is flagged as an error.\n\
7022 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
7023 of errors.\n\
7024 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
7025 arguments.\n\
7026 PL_PARSE_SHOWALL (8) -- Show invisible options\n\
7027 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
7028 pointer to the program name.\n\
7029 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required.\n\
7030 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
7031 unrecognized arguments.\n\
7032 ";
7033 static const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
7034 Initialization\n\
7035 \n\
7036 DESCRIPTION:\n\
7037 \n\
7038 Initializing the plotting package. The program prompts for the device\n\
7039 keyword or number of the desired output device. Hitting a RETURN in\n\
7040 response to the prompt is the same as selecting the first device. If\n\
7041 only one device is enabled when PLplot is installed, plstar will issue\n\
7042 no prompt. The output device is divided into nx by ny subpages, each\n\
7043 of which may be used independently. The subroutine pladv is used to\n\
7044 advance from one subpage to the next.\n\
7045 \n\
7046 Redacted form: plstar(nx, ny)\n\
7047 \n\
7048 This function is used in example 1.\n\
7049 \n\
7050 \n\
7051 \n\
7052 SYNOPSIS:\n\
7053 \n\
7054 plstar(nx, ny)\n\
7055 \n\
7056 ARGUMENTS:\n\
7057 \n\
7058 nx (PLINT, input) : Number of subpages to divide output page in the\n\
7059 x direction.\n\
7060 \n\
7061 ny (PLINT, input) : Number of subpages to divide output page in the\n\
7062 y direction.\n\
7063 ";
7064 static const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
7065 Get FCI (font characterization integer)\n\
7066 \n\
7067 DESCRIPTION:\n\
7068 \n\
7069 Gets information about the current font using the FCI approach. See\n\
7070 the PLplot documentation for more information.\n\
7071 \n\
7072 Redacted form: plgfci(p_fci)\n\
7073 \n\
7074 This function is used in example 23.\n\
7075 \n\
7076 \n\
7077 \n\
7078 SYNOPSIS:\n\
7079 \n\
7080 plgfci(p_fci)\n\
7081 \n\
7082 ARGUMENTS:\n\
7083 \n\
7084 p_fci (PLUNICODE_NC_SCALAR, output) : Returned value of the current\n\
7085 FCI value.\n\
7086 ";
7087 static const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
7088 Set family file parameters\n\
7089 \n\
7090 DESCRIPTION:\n\
7091 \n\
7092 Sets variables dealing with output file familying. Does nothing if\n\
7093 familying not supported by the driver. This routine, if used, must be\n\
7094 called before initializing PLplot. See the PLplot documentation for\n\
7095 more information.\n\
7096 \n\
7097 Redacted form: plsfam(fam, num, bmax)\n\
7098 \n\
7099 This function is used in examples 14 and 31.\n\
7100 \n\
7101 \n\
7102 \n\
7103 SYNOPSIS:\n\
7104 \n\
7105 plsfam(fam, num, bmax)\n\
7106 \n\
7107 ARGUMENTS:\n\
7108 \n\
7109 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
7110 is enabled.\n\
7111 \n\
7112 num (PLINT, input) : Current family file number.\n\
7113 \n\
7114 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
7115 file.\n\
7116 ";
7117 static const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
7118 Set cmap1 colors and alpha transparency using a piece-wise linear relationship\n\
7119 \n\
7120 DESCRIPTION:\n\
7121 \n\
7122 This is a variant of plscmap1l that supports alpha channel\n\
7123 transparency. It sets cmap1 colors using a piece-wise linear\n\
7124 relationship between cmap1 intensity index (0.0-1.0) and position in\n\
7125 HLS or RGB color space (see the PLplot documentation) with alpha\n\
7126 transparency value (0.0-1.0). It may be called at any time.\n\
7127 \n\
7128 Redacted form: plscmap1la(itype, intensity, coord1, coord2, coord3,\n\
7129 alpha, alt_hue_path)\n\
7130 \n\
7131 This function is used in example 30.\n\
7132 \n\
7133 \n\
7134 \n\
7135 SYNOPSIS:\n\
7136 \n\
7137 plscmap1la(itype, npts, intensity, coord1, coord2, coord3, alpha, alt_hue_path)\n\
7138 \n\
7139 ARGUMENTS:\n\
7140 \n\
7141 itype (PLBOOL, input) : true: RGB, false: HLS.\n\
7142 \n\
7143 npts (PLINT, input) : number of control points.\n\
7144 \n\
7145 intensity (PLFLT_VECTOR, input) : A vector containing the cmap1\n\
7146 intensity index (0.0-1.0) in ascending order for each control\n\
7147 point.\n\
7148 \n\
7149 coord1 (PLFLT_VECTOR, input) : A vector containing the first\n\
7150 coordinate (H or R) for each control point.\n\
7151 \n\
7152 coord2 (PLFLT_VECTOR, input) : A vector containing the second\n\
7153 coordinate (L or G) for each control point.\n\
7154 \n\
7155 coord3 (PLFLT_VECTOR, input) : A vector containing the third\n\
7156 coordinate (S or B) for each control point.\n\
7157 \n\
7158 alpha (PLFLT_VECTOR, input) : A vector containing the alpha\n\
7159 transparency value (0.0-1.0) for each control point.\n\
7160 \n\
7161 alt_hue_path (PLBOOL_VECTOR, input) : A vector (with\n\
7162 npts - 1 elements) containing the alternative interpolation method\n\
7163 Boolean value for each control point interval. (alt_hue_path[i]\n\
7164 refers to the interpolation interval between the i and i + 1\n\
7165 control points).\n\
7166 ";
7167 static const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
7168 Set page parameters\n\
7169 \n\
7170 DESCRIPTION:\n\
7171 \n\
7172 Sets the page configuration (optional). If an individual parameter is\n\
7173 zero then that parameter value is not updated. Not all parameters are\n\
7174 recognized by all drivers and the interpretation is device-dependent.\n\
7175 The X-window driver uses the length and offset parameters to determine\n\
7176 the window size and location. The length and offset values are\n\
7177 expressed in units that are specific to the current driver. For\n\
7178 instance: screen drivers will usually interpret them as number of\n\
7179 pixels, whereas printer drivers will usually use mm.\n\
7180 \n\
7181 This routine, if used, must be called before initializing PLplot. It\n\
7182 may be called at later times for interactive drivers to change only\n\
7183 the dpi for subsequent redraws which you can force via a call to\n\
7184 plreplot. If this function is not called then the page size defaults\n\
7185 to landscape A4 for drivers which use real world page sizes and 744\n\
7186 pixels wide by 538 pixels high for raster drivers. The default value\n\
7187 for dx and dy is 90 pixels per inch for raster drivers.\n\
7188 \n\
7189 \n\
7190 \n\
7191 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7192 \n\
7193 This function is used in examples 14 and 31.\n\
7194 \n\
7195 \n\
7196 \n\
7197 SYNOPSIS:\n\
7198 \n\
7199 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
7200 \n\
7201 ARGUMENTS:\n\
7202 \n\
7203 xp (PLFLT, input) : Number of pixels per inch (DPI), x. Used only\n\
7204 by raster drivers, ignored by drivers which use \"real world\" units\n\
7205 (e.g. mm).\n\
7206 \n\
7207 yp (PLFLT, input) : Number of pixels per inch (DPI), y. Used only\n\
7208 by raster drivers, ignored by drivers which use \"real world\" units\n\
7209 (e.g. mm).\n\
7210 \n\
7211 xleng (PLINT, input) : Page length, x.\n\
7212 \n\
7213 yleng (PLINT, input) : Page length, y.\n\
7214 \n\
7215 xoff (PLINT, input) : Page offset, x.\n\
7216 \n\
7217 yoff (PLINT, input) : Page offset, y.\n\
7218 ";
7219 static const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
7220 Set precision in numeric labels\n\
7221 \n\
7222 DESCRIPTION:\n\
7223 \n\
7224 Sets the number of places after the decimal point in numeric labels.\n\
7225 \n\
7226 Redacted form: plprec(setp, prec)\n\
7227 \n\
7228 This function is used in example 29.\n\
7229 \n\
7230 \n\
7231 \n\
7232 SYNOPSIS:\n\
7233 \n\
7234 plprec(setp, prec)\n\
7235 \n\
7236 ARGUMENTS:\n\
7237 \n\
7238 setp (PLINT, input) : If setp is equal to 0 then PLplot\n\
7239 automatically determines the number of places to use after the\n\
7240 decimal point in numeric labels (like those used to label axes).\n\
7241 If setp is 1 then prec sets the number of places.\n\
7242 \n\
7243 prec (PLINT, input) : The number of characters to draw after the\n\
7244 decimal point in numeric labels.\n\
7245 ";
7246 static const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
7247 Copy state parameters from the reference stream to the current stream\n\
7248 \n\
7249 DESCRIPTION:\n\
7250 \n\
7251 Copies state parameters from the reference stream to the current\n\
7252 stream. Tell driver interface to map device coordinates unless flags\n\
7253 == 1.\n\
7254 \n\
7255 This function is used for making save files of selected plots (e.g.\n\
7256 from the TK driver). After initializing, you can get a copy of the\n\
7257 current plot to the specified device by switching to this stream and\n\
7258 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
7259 appropriate. The plot buffer must have previously been enabled (done\n\
7260 automatically by some display drivers, such as X).\n\
7261 \n\
7262 Redacted form: plcpstrm(iplsr, flags)\n\
7263 \n\
7264 This function is used in example 1,20.\n\
7265 \n\
7266 \n\
7267 \n\
7268 SYNOPSIS:\n\
7269 \n\
7270 plcpstrm(iplsr, flags)\n\
7271 \n\
7272 ARGUMENTS:\n\
7273 \n\
7274 iplsr (PLINT, input) : Number of reference stream.\n\
7275 \n\
7276 flags (PLBOOL, input) : If flags is set to true the device\n\
7277 coordinates are not copied from the reference to current stream.\n\
7278 ";
7279 static const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
7280 Plot a glyph at the specified points\n\
7281 \n\
7282 DESCRIPTION:\n\
7283 \n\
7284 Plot a glyph at the specified points. (This function is largely\n\
7285 superseded by plstring which gives access to many[!] more glyphs.)\n\
7286 code=-1 means try to just draw a point. Right now it\'s just a move\n\
7287 and a draw at the same place. Not ideal, since a sufficiently\n\
7288 intelligent output device may optimize it away, or there may be faster\n\
7289 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7290 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7291 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7292 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7293 code <= 127 the corresponding printable ASCII character is plotted.\n\
7294 \n\
7295 Redacted form: plpoin(x, y, code)\n\
7296 \n\
7297 This function is used in examples 1, 6, 14, and 29.\n\
7298 \n\
7299 \n\
7300 \n\
7301 SYNOPSIS:\n\
7302 \n\
7303 plpoin(n, x, y, code)\n\
7304 \n\
7305 ARGUMENTS:\n\
7306 \n\
7307 n (PLINT, input) : Number of points in the x and y vectors.\n\
7308 \n\
7309 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7310 points.\n\
7311 \n\
7312 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7313 points.\n\
7314 \n\
7315 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7316 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7317 each of the n points.\n\
7318 ";
7319 static const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
7320 Enter or leave xor mode\n\
7321 \n\
7322 DESCRIPTION:\n\
7323 \n\
7324 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
7325 those drivers (e.g., the xwin driver) that support it. Enables\n\
7326 erasing plots by drawing twice the same line, symbol, etc. If driver\n\
7327 is not capable of xor operation it returns a status of false.\n\
7328 \n\
7329 Redacted form: plxormod(mode, status)\n\
7330 \n\
7331 This function is used in examples 1 and 20.\n\
7332 \n\
7333 \n\
7334 \n\
7335 SYNOPSIS:\n\
7336 \n\
7337 plxormod(mode, status)\n\
7338 \n\
7339 ARGUMENTS:\n\
7340 \n\
7341 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
7342 is false means leave xor mode.\n\
7343 \n\
7344 status (PLBOOL_NC_SCALAR, output) : Returned value of the status.\n\
7345 modestatus of true (false) means driver is capable (incapable) of\n\
7346 xor mode.\n\
7347 ";
7348 static const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
7349 Get viewport limits in normalized device coordinates\n\
7350 \n\
7351 DESCRIPTION:\n\
7352 \n\
7353 Get viewport limits in normalized device coordinates.\n\
7354 \n\
7355 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7356 \n\
7357 \n\
7358 This function is used in example 31.\n\
7359 \n\
7360 \n\
7361 \n\
7362 SYNOPSIS:\n\
7363 \n\
7364 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
7365 \n\
7366 ARGUMENTS:\n\
7367 \n\
7368 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7369 viewport limit of the normalized device coordinate in x.\n\
7370 \n\
7371 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7372 viewport limit of the normalized device coordinate in x.\n\
7373 \n\
7374 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
7375 viewport limit of the normalized device coordinate in y.\n\
7376 \n\
7377 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
7378 viewport limit of the normalized device coordinate in y.\n\
7379 ";
7380 static const char* _wrap_plmesh_texinfo = "-*- texinfo -*-\n\
7381 Plot surface mesh\n\
7382 \n\
7383 DESCRIPTION:\n\
7384 \n\
7385 Plots a surface mesh within the environment set up by plw3d. The\n\
7386 surface is defined by the matrix z[\n\
7387 nx][\n\
7388 ny] , the point z[i][j] being the value of the function at (\n\
7389 x[i],\n\
7390 y[j]). Note that the points in vectors x and y do not need to be\n\
7391 equally spaced, but must be stored in ascending order. The parameter\n\
7392 opt controls the way in which the surface is displayed. For further\n\
7393 details see the PLplot documentation.\n\
7394 \n\
7395 Redacted form: plmesh(x, y, z, opt)\n\
7396 \n\
7397 This function is used in example 11.\n\
7398 \n\
7399 \n\
7400 \n\
7401 SYNOPSIS:\n\
7402 \n\
7403 plmesh(x, y, z, nx, ny, opt)\n\
7404 \n\
7405 ARGUMENTS:\n\
7406 \n\
7407 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7408 which the function is evaluated.\n\
7409 \n\
7410 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7411 which the function is evaluated.\n\
7412 \n\
7413 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7414 plot. Should have dimensions of\n\
7415 nx by\n\
7416 ny.\n\
7417 \n\
7418 nx (PLINT, input) : Number of x values at which function has been\n\
7419 evaluated.\n\
7420 \n\
7421 ny (PLINT, input) : Number of y values at which function has been\n\
7422 evaluated.\n\
7423 \n\
7424 opt (PLINT, input) : Determines the way in which the surface is\n\
7425 represented: opt=DRAW_LINEX : Lines are drawn showing z as a\n\
7426 function of x for each value of y[j] .\n\
7427 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7428 for each value of x[i] .\n\
7429 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7430 at which function is defined.\n\
7431 ";
7432 static const char* _wrap_plmeshc_texinfo = "-*- texinfo -*-\n\
7433 Magnitude colored plot surface mesh with contour\n\
7434 \n\
7435 DESCRIPTION:\n\
7436 \n\
7437 A more powerful form of plmesh: the surface mesh can be colored\n\
7438 accordingly to the current z value being plotted, a contour plot can\n\
7439 be drawn at the base XY plane, and a curtain can be drawn between the\n\
7440 plotted function border and the base XY plane.\n\
7441 \n\
7442 Redacted form: plmeshc(x, y, z, opt, clevel)\n\
7443 \n\
7444 This function is used in example 11.\n\
7445 \n\
7446 \n\
7447 \n\
7448 SYNOPSIS:\n\
7449 \n\
7450 plmeshc(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7451 \n\
7452 ARGUMENTS:\n\
7453 \n\
7454 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7455 which the function is evaluated.\n\
7456 \n\
7457 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7458 which the function is evaluated.\n\
7459 \n\
7460 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7461 plot. Should have dimensions of\n\
7462 nx by\n\
7463 ny.\n\
7464 \n\
7465 nx (PLINT, input) : Number of x values at which function is\n\
7466 evaluated.\n\
7467 \n\
7468 ny (PLINT, input) : Number of y values at which function is\n\
7469 evaluated.\n\
7470 \n\
7471 opt (PLINT, input) : Determines the way in which the surface is\n\
7472 represented. To specify more than one option just add the options,\n\
7473 e.g. DRAW_LINEXY + MAG_COLOR opt=DRAW_LINEX : Lines are drawn\n\
7474 showing z as a function of x for each value of y[j] .\n\
7475 opt=DRAW_LINEY : Lines are drawn showing z as a function of y\n\
7476 for each value of x[i] .\n\
7477 opt=DRAW_LINEXY : Network of lines is drawn connecting points\n\
7478 at which function is defined.\n\
7479 opt=MAG_COLOR : Each line in the mesh is colored according to\n\
7480 the z value being plotted. The color is used from the current\n\
7481 cmap1.\n\
7482 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7483 using parameters\n\
7484 nlevel and\n\
7485 clevel.\n\
7486 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7487 the borders of the plotted function.\n\
7488 \n\
7489 \n\
7490 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7491 levels.\n\
7492 \n\
7493 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7494 ";
7495 static const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
7496 End plotting session for current stream\n\
7497 \n\
7498 DESCRIPTION:\n\
7499 \n\
7500 Ends a plotting session for the current output stream only. See\n\
7501 plsstrm for more info.\n\
7502 \n\
7503 Redacted form: plend1()\n\
7504 \n\
7505 This function is used in examples 1 and 20.\n\
7506 \n\
7507 \n\
7508 \n\
7509 SYNOPSIS:\n\
7510 \n\
7511 plend1()\n\
7512 ";
7513 static const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
7514 Get y axis parameters\n\
7515 \n\
7516 DESCRIPTION:\n\
7517 \n\
7518 Identical to plgxax, except that arguments are flags for y axis. See\n\
7519 the description of plgxax for more detail.\n\
7520 \n\
7521 Redacted form: plgyax(p_digmax, p_digits)\n\
7522 \n\
7523 This function is used in example 31.\n\
7524 \n\
7525 \n\
7526 \n\
7527 SYNOPSIS:\n\
7528 \n\
7529 plgyax(p_digmax, p_digits)\n\
7530 \n\
7531 ARGUMENTS:\n\
7532 \n\
7533 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
7534 number of digits for the y axis. If nonzero, the printed label\n\
7535 has been switched to a floating-point representation when the\n\
7536 number of digits exceeds this value.\n\
7537 \n\
7538 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
7539 number of digits for the numeric labels (y axis) from the last\n\
7540 plot.\n\
7541 ";
7542 static const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
7543 Set plot orientation\n\
7544 \n\
7545 DESCRIPTION:\n\
7546 \n\
7547 Set plot orientation parameter which is multiplied by 90 degrees to\n\
7548 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
7549 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
7550 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
7551 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
7552 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
7553 not called the default value of rot is 0.\n\
7554 \n\
7555 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
7556 probably want to change the aspect ratio to a value suitable for the\n\
7557 plot orientation using a call to plsdidev or the command-line options\n\
7558 -a or -freeaspect. For more documentation of those options see the\n\
7559 PLplot documentation. Such command-line options can be set internally\n\
7560 using plsetopt or set directly using the command line and parsed using\n\
7561 a call to plparseopts.\n\
7562 \n\
7563 Redacted form: plsdiori(rot)\n\
7564 \n\
7565 This function is not used in any examples.\n\
7566 \n\
7567 \n\
7568 \n\
7569 SYNOPSIS:\n\
7570 \n\
7571 plsdiori(rot)\n\
7572 \n\
7573 ARGUMENTS:\n\
7574 \n\
7575 rot (PLFLT, input) : Plot orientation parameter.\n\
7576 ";
7577 static const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
7578 Plot a histogram from unbinned data\n\
7579 \n\
7580 DESCRIPTION:\n\
7581 \n\
7582 Plots a histogram from n data points stored in the data vector. This\n\
7583 routine bins the data into nbin bins equally spaced between datmin and\n\
7584 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
7585 opt allows, among other things, the histogram either to be plotted in\n\
7586 an existing window or causes plhist to call plenv with suitable limits\n\
7587 before plotting the histogram.\n\
7588 \n\
7589 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
7590 \n\
7591 This function is used in example 5.\n\
7592 \n\
7593 \n\
7594 \n\
7595 SYNOPSIS:\n\
7596 \n\
7597 plhist(n, data, datmin, datmax, nbin, opt)\n\
7598 \n\
7599 ARGUMENTS:\n\
7600 \n\
7601 n (PLINT, input) : Number of data points.\n\
7602 \n\
7603 data (PLFLT_VECTOR, input) : A vector containing the values of the\n\
7604 n data points.\n\
7605 \n\
7606 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin.\n\
7607 \n\
7608 datmax (PLFLT, input) : Right-hand edge of highest-valued bin.\n\
7609 \n\
7610 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
7611 divide the interval xmin to xmax.\n\
7612 \n\
7613 opt (PLINT, input) : Is a combination of several flags:\n\
7614 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
7615 the histogram data, the outer bins are expanded to fill up the\n\
7616 entire x-axis, data outside the given extremes are assigned to the\n\
7617 outer bins and bins of zero height are simply drawn.\n\
7618 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
7619 to fit the histogram data, without this flag, plenv is called\n\
7620 to set the world coordinates.\n\
7621 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
7622 extremes are not taken into account. This option should\n\
7623 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
7624 properly present the data.\n\
7625 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
7626 size as the ones inside.\n\
7627 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
7628 (there is a gap for such bins).\n\
7629 ";
7630 static const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
7631 End plotting session\n\
7632 \n\
7633 DESCRIPTION:\n\
7634 \n\
7635 Ends a plotting session, tidies up all the output files, switches\n\
7636 interactive devices back into text mode and frees up any memory that\n\
7637 was allocated. Must be called before end of program.\n\
7638 \n\
7639 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
7640 wait state after a call to plend or other functions which trigger the\n\
7641 end of a plot page. To avoid this, use the plspause function.\n\
7642 \n\
7643 Redacted form: plend()\n\
7644 \n\
7645 This function is used in all of the examples.\n\
7646 \n\
7647 \n\
7648 \n\
7649 SYNOPSIS:\n\
7650 \n\
7651 plend()\n\
7652 ";
7653 static const char* _wrap_plsurf3d_texinfo = "-*- texinfo -*-\n\
7654 Plot shaded 3-d surface plot\n\
7655 \n\
7656 DESCRIPTION:\n\
7657 \n\
7658 Plots a three-dimensional shaded surface plot within the environment\n\
7659 set up by plw3d. The surface is defined by the two-dimensional matrix\n\
7660 z[\n\
7661 nx][\n\
7662 ny], the point z[i][j] being the value of the function at (\n\
7663 x[i],\n\
7664 y[j]). Note that the points in vectors x and y do not need to be\n\
7665 equally spaced, but must be stored in ascending order. For further\n\
7666 details see the PLplot documentation.\n\
7667 \n\
7668 Redacted form: plsurf3d(x, y, z, opt, clevel)\n\
7669 \n\
7670 This function is not used in any examples.\n\
7671 \n\
7672 \n\
7673 \n\
7674 SYNOPSIS:\n\
7675 \n\
7676 plsurf3d(x, y, z, nx, ny, opt, clevel, nlevel)\n\
7677 \n\
7678 ARGUMENTS:\n\
7679 \n\
7680 x (PLFLT_VECTOR, input) : A vector containing the x coordinates at\n\
7681 which the function is evaluated.\n\
7682 \n\
7683 y (PLFLT_VECTOR, input) : A vector containing the y coordinates at\n\
7684 which the function is evaluated.\n\
7685 \n\
7686 z (PLFLT_MATRIX, input) : A matrix containing function values to\n\
7687 plot. Should have dimensions of\n\
7688 nx by\n\
7689 ny.\n\
7690 \n\
7691 nx (PLINT, input) : Number of x values at which function is\n\
7692 evaluated.\n\
7693 \n\
7694 ny (PLINT, input) : Number of y values at which function is\n\
7695 evaluated.\n\
7696 \n\
7697 opt (PLINT, input) : Determines the way in which the surface is\n\
7698 represented. To specify more than one option just add the options,\n\
7699 e.g. FACETED + SURF_CONT opt=FACETED : Network of lines is drawn\n\
7700 connecting points at which function is defined.\n\
7701 opt=BASE_CONT : A contour plot is drawn at the base XY plane\n\
7702 using parameters\n\
7703 nlevel and\n\
7704 clevel.\n\
7705 opt=SURF_CONT : A contour plot is drawn at the surface plane\n\
7706 using parameters\n\
7707 nlevel and\n\
7708 clevel.\n\
7709 opt=DRAW_SIDES : draws a curtain between the base XY plane and\n\
7710 the borders of the plotted function.\n\
7711 opt=MAG_COLOR : the surface is colored according to the value\n\
7712 of Z; if MAG_COLOR is not used, then the surface is colored\n\
7713 according to the intensity of the reflected light in the\n\
7714 surface from a light source whose position is set using\n\
7715 pllightsource.\n\
7716 \n\
7717 \n\
7718 clevel (PLFLT_VECTOR, input) : A vector containing the contour\n\
7719 levels.\n\
7720 \n\
7721 nlevel (PLINT, input) : Number of elements in the clevel vector.\n\
7722 ";
7723 static const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
7724 Set device-compression level\n\
7725 \n\
7726 DESCRIPTION:\n\
7727 \n\
7728 Set device-compression level. Only used for drivers that provide\n\
7729 compression. This function, if used, should be invoked before a call\n\
7730 to plinit.\n\
7731 \n\
7732 Redacted form: plscompression(compression)\n\
7733 \n\
7734 This function is used in example 31.\n\
7735 \n\
7736 \n\
7737 \n\
7738 SYNOPSIS:\n\
7739 \n\
7740 plscompression(compression)\n\
7741 \n\
7742 ARGUMENTS:\n\
7743 \n\
7744 compression (PLINT, input) : The desired compression level. This is\n\
7745 a device-dependent value. Currently only the jpeg and png devices\n\
7746 use these values. For jpeg value is the jpeg quality which should\n\
7747 normally be in the range 0-95. Higher values denote higher quality\n\
7748 and hence larger image sizes. For png values are in the range -1\n\
7749 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
7750 A value of -1 denotes the default zlib compression level. Values\n\
7751 in the range 10-99 are divided by 10 and then used as the zlib\n\
7752 compression level. Higher compression levels correspond to greater\n\
7753 compression and small file sizes at the expense of more\n\
7754 computation.\n\
7755 ";
7756 static const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
7757 Get the current device-compression setting\n\
7758 \n\
7759 DESCRIPTION:\n\
7760 \n\
7761 Get the current device-compression setting. This parameter is only\n\
7762 used for drivers that provide compression.\n\
7763 \n\
7764 Redacted form: plgcompression(compression)\n\
7765 \n\
7766 This function is used in example 31.\n\
7767 \n\
7768 \n\
7769 \n\
7770 SYNOPSIS:\n\
7771 \n\
7772 plgcompression(compression)\n\
7773 \n\
7774 ARGUMENTS:\n\
7775 \n\
7776 compression (PLINT_NC_SCALAR, output) : Returned value of the\n\
7777 compression setting for the current device.\n\
7778 ";
7779 static const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
7780 Advance the (sub-)page\n\
7781 \n\
7782 DESCRIPTION:\n\
7783 \n\
7784 Advances to the next subpage if sub=0, performing a page advance if\n\
7785 there are no remaining subpages on the current page. If subpages\n\
7786 aren\'t being used, pladv(0) will always advance the page. If page>0,\n\
7787 PLplot switches to the specified subpage. Note that this allows you\n\
7788 to overwrite a plot on the specified subpage; if this is not what you\n\
7789 intended, use pleop followed by plbop to first advance the page. This\n\
7790 routine is called automatically (with page=0) by plenv, but if plenv\n\
7791 is not used, pladv must be called after initializing PLplot but before\n\
7792 defining the viewport.\n\
7793 \n\
7794 Redacted form: pladv(page)\n\
7795 \n\
7796 This function is used in examples 1, 2, 4, 6-12, 14-18, 20, 21, 23-27,\n\
7797 29, and 31.\n\
7798 \n\
7799 \n\
7800 \n\
7801 SYNOPSIS:\n\
7802 \n\
7803 pladv(page)\n\
7804 \n\
7805 ARGUMENTS:\n\
7806 \n\
7807 page (PLINT, input) : Specifies the subpage number (starting from 1\n\
7808 in the top left corner and increasing along the rows) to which to\n\
7809 advance. Set to zero to advance to the next subpage (or to the\n\
7810 next page if subpages are not being used).\n\
7811 ";
7812 static const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
7813 Set parameters of contour labelling other than format of numerical label\n\
7814 \n\
7815 DESCRIPTION:\n\
7816 \n\
7817 Set parameters of contour labelling other than those handled by\n\
7818 pl_setcontlabelformat.\n\
7819 \n\
7820 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
7821 \n\
7822 This function is used in example 9.\n\
7823 \n\
7824 \n\
7825 \n\
7826 SYNOPSIS:\n\
7827 \n\
7828 pl_setcontlabelparam(offset, size, spacing, active)\n\
7829 \n\
7830 ARGUMENTS:\n\
7831 \n\
7832 offset (PLFLT, input) : Offset of label from contour line (if set\n\
7833 to 0.0, labels are printed on the lines). Default value is 0.006.\n\
7834 \n\
7835 size (PLFLT, input) : Font height for contour labels (normalized).\n\
7836 Default value is 0.3.\n\
7837 \n\
7838 spacing (PLFLT, input) : Spacing parameter for contour labels.\n\
7839 Default value is 0.1.\n\
7840 \n\
7841 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
7842 contour labels on. Default is off (0).\n\
7843 ";
7844 static const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
7845 Set family, style and weight of the current font\n\
7846 \n\
7847 DESCRIPTION:\n\
7848 \n\
7849 Sets the current font. See the PLplot documentation for more\n\
7850 information on font selection.\n\
7851 \n\
7852 Redacted form: plsfont(family, style, weight)\n\
7853 \n\
7854 This function is used in example 23.\n\
7855 \n\
7856 \n\
7857 \n\
7858 SYNOPSIS:\n\
7859 \n\
7860 plsfont(family, style, weight)\n\
7861 \n\
7862 ARGUMENTS:\n\
7863 \n\
7864 family (PLINT, input) : Font family to select for the current font.\n\
7865 The available values are given by the PL_FCI_* constants in\n\
7866 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF,\n\
7867 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
7868 signifies that the font family should not be altered.\n\
7869 \n\
7870 style (PLINT, input) : Font style to select for the current font.\n\
7871 The available values are given by the PL_FCI_* constants in\n\
7872 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
7873 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
7874 should not be altered.\n\
7875 \n\
7876 weight (PLINT, input) : Font weight to select for the current font.\n\
7877 The available values are given by the PL_FCI_* constants in\n\
7878 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
7879 negative value signifies that the font weight should not be\n\
7880 altered.\n\
7881 ";
7882 static const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
7883 Sets the 3D position of the light source\n\
7884 \n\
7885 DESCRIPTION:\n\
7886 \n\
7887 Sets the 3D position of the light source for use with plsurf3d and\n\
7888 plsurf3dl\n\
7889 \n\
7890 Redacted form: pllightsource(x, y, z)\n\
7891 \n\
7892 This function is used in example 8.\n\
7893 \n\
7894 \n\
7895 \n\
7896 SYNOPSIS:\n\
7897 \n\
7898 pllightsource(x, y, z)\n\
7899 \n\
7900 ARGUMENTS:\n\
7901 \n\
7902 x (PLFLT, input) : X-coordinate of the light source.\n\
7903 \n\
7904 y (PLFLT, input) : Y-coordinate of the light source.\n\
7905 \n\
7906 z (PLFLT, input) : Z-coordinate of the light source.\n\
7907 ";
7908 static const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
7909 Draw a line\n\
7910 \n\
7911 DESCRIPTION:\n\
7912 \n\
7913 Draws line defined by n points in x and y.\n\
7914 \n\
7915 Redacted form: plline(x, y)\n\
7916 \n\
7917 This function is used in examples 1, 3, 4, 9, 12-14, 16, 18, 20, 22,\n\
7918 25-27, and 29.\n\
7919 \n\
7920 \n\
7921 \n\
7922 SYNOPSIS:\n\
7923 \n\
7924 plline(n, x, y)\n\
7925 \n\
7926 ARGUMENTS:\n\
7927 \n\
7928 n (PLINT, input) : Number of points defining line.\n\
7929 \n\
7930 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7931 points.\n\
7932 \n\
7933 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
7934 points.\n\
7935 ";
7936 static const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
7937 Set pen width\n\
7938 \n\
7939 DESCRIPTION:\n\
7940 \n\
7941 Sets the pen width.\n\
7942 \n\
7943 Redacted form: plwidth(width)\n\
7944 \n\
7945 This function is used in examples 1 and 2.\n\
7946 \n\
7947 \n\
7948 \n\
7949 SYNOPSIS:\n\
7950 \n\
7951 plwidth(width)\n\
7952 \n\
7953 ARGUMENTS:\n\
7954 \n\
7955 width (PLFLT, input) : The desired pen width. If width is negative\n\
7956 or the same as the previous value no action is taken. width = 0.\n\
7957 should be interpreted as as the minimum valid pen width for the\n\
7958 device. The interpretation of positive width values is also\n\
7959 device dependent.\n\
7960 ";
7961 static const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
7962 Draw linear gradient inside polygon\n\
7963 \n\
7964 DESCRIPTION:\n\
7965 \n\
7966 Draw a linear gradient using cmap1 inside the polygon defined by the n\n\
7967 points (\n\
7968 x[i],\n\
7969 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
7970 polygon coordinates and the gradient angle are all expressed in world\n\
7971 coordinates. The angle from the x axis for both the rotated\n\
7972 coordinate system and the gradient vector is specified by angle. The\n\
7973 magnitude of the gradient vector is the difference between the maximum\n\
7974 and minimum values of x for the vertices in the rotated coordinate\n\
7975 system. The origin of the gradient vector can be interpreted as being\n\
7976 anywhere on the line corresponding to the minimum x value for the\n\
7977 vertices in the rotated coordinate system. The distance along the\n\
7978 gradient vector is linearly transformed to the independent variable of\n\
7979 color map 1 which ranges from 0. at the tail of the gradient vector to\n\
7980 1. at the head of the gradient vector. What is drawn is the RGBA\n\
7981 color corresponding to the independent variable of cmap1. For more\n\
7982 information about cmap1 (see the PLplot documentation).\n\
7983 \n\
7984 Redacted form: plgradient(x,y,angle)\n\
7985 \n\
7986 This function is used in examples 25 and 30.\n\
7987 \n\
7988 \n\
7989 \n\
7990 SYNOPSIS:\n\
7991 \n\
7992 plgradient(n, x, y, angle)\n\
7993 \n\
7994 ARGUMENTS:\n\
7995 \n\
7996 n (PLINT, input) : Number of vertices in polygon.\n\
7997 \n\
7998 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
7999 vertices.\n\
8000 \n\
8001 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
8002 vertices.\n\
8003 \n\
8004 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
8005 axis.\n\
8006 ";
8007 static const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
8008 Flushes the output stream\n\
8009 \n\
8010 DESCRIPTION:\n\
8011 \n\
8012 Flushes the output stream. Use sparingly, if at all.\n\
8013 \n\
8014 Redacted form: plflush()\n\
8015 \n\
8016 This function is used in examples 1 and 14.\n\
8017 \n\
8018 \n\
8019 \n\
8020 SYNOPSIS:\n\
8021 \n\
8022 plflush()\n\
8023 ";
8024 static const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
8025 Get plot orientation\n\
8026 \n\
8027 DESCRIPTION:\n\
8028 \n\
8029 Get plot orientation parameter which is multiplied by 90 degrees to\n\
8030 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
8031 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
8032 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
8033 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
8034 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
8035 not been called the default value pointed to by p_rot will be 0.\n\
8036 \n\
8037 Redacted form: plgdiori(p_rot)\n\
8038 \n\
8039 This function is not used in any examples.\n\
8040 \n\
8041 \n\
8042 \n\
8043 SYNOPSIS:\n\
8044 \n\
8045 plgdiori(p_rot)\n\
8046 \n\
8047 ARGUMENTS:\n\
8048 \n\
8049 p_rot (PLFLT_NC_SCALAR, output) : Returned value of the orientation\n\
8050 parameter.\n\
8051 ";
8052 static const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
8053 Set x axis parameters\n\
8054 \n\
8055 DESCRIPTION:\n\
8056 \n\
8057 Sets values of the digmax and digits flags for the x axis. See the\n\
8058 PLplot documentation for more information.\n\
8059 \n\
8060 Redacted form: plsxax(digmax, digits)\n\
8061 \n\
8062 This function is used in example 31.\n\
8063 \n\
8064 \n\
8065 \n\
8066 SYNOPSIS:\n\
8067 \n\
8068 plsxax(digmax, digits)\n\
8069 \n\
8070 ARGUMENTS:\n\
8071 \n\
8072 digmax (PLINT, input) : Variable to set the maximum number of\n\
8073 digits for the x axis. If nonzero, the printed label will be\n\
8074 switched to a floating-point representation when the number of\n\
8075 digits exceeds digmax.\n\
8076 \n\
8077 digits (PLINT, input) : Field digits value. Currently, changing\n\
8078 its value here has no effect since it is set only by plbox or\n\
8079 plbox3. However, the user may obtain its value after a call to\n\
8080 either of these functions by calling plgxax.\n\
8081 ";
8082 static const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
8083 Get viewport limits in world coordinates\n\
8084 \n\
8085 DESCRIPTION:\n\
8086 \n\
8087 Get viewport limits in world coordinates.\n\
8088 \n\
8089 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8090 \n\
8091 \n\
8092 This function is used in example 31.\n\
8093 \n\
8094 \n\
8095 \n\
8096 SYNOPSIS:\n\
8097 \n\
8098 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
8099 \n\
8100 ARGUMENTS:\n\
8101 \n\
8102 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8103 viewport limit of the world coordinate in x.\n\
8104 \n\
8105 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8106 viewport limit of the world coordinate in x.\n\
8107 \n\
8108 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the lower\n\
8109 viewport limit of the world coordinate in y.\n\
8110 \n\
8111 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the upper\n\
8112 viewport limit of the world coordinate in y.\n\
8113 ";
8114 static const char* _wrap_plshades_texinfo = "-*- texinfo -*-\n\
8115 Shade regions on the basis of value\n\
8116 \n\
8117 DESCRIPTION:\n\
8118 \n\
8119 Shade regions on the basis of value. This is the high-level routine\n\
8120 for making continuous color shaded plots with cmap1 while plshade\n\
8121 should be used to plot individual shaded regions using either cmap0 or\n\
8122 cmap1. examples/;<language>/x16* shows how to use plshades for each of\n\
8123 our supported languages.\n\
8124 \n\
8125 Redacted form: General: plshades(a, defined, xmin, xmax, ymin, ymax,\n\
8126 clevel, fill_width, cont_color, cont_width, fill, rectangular, pltr,\n\
8127 pltr_data)\n\
8128 \n\
8129 \n\
8130 This function is used in examples 16, 21, and 22.\n\
8131 \n\
8132 \n\
8133 \n\
8134 SYNOPSIS:\n\
8135 \n\
8136 plshades(a, nx, ny, defined, xmin, xmax, ymin, ymax, clevel, nlevel, fill_width, cont_color, cont_width, fill, rectangular, pltr, pltr_data)\n\
8137 \n\
8138 ARGUMENTS:\n\
8139 \n\
8140 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8141 plot. Should have dimensions of\n\
8142 nx by\n\
8143 ny.\n\
8144 \n\
8145 nx (PLINT, input) : First dimension of matrix \"a\".\n\
8146 \n\
8147 ny (PLINT, input) : Second dimension of matrix \"a\".\n\
8148 \n\
8149 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8150 the region that should be plotted in the shade plot. This\n\
8151 function accepts x and y coordinates as input arguments and must\n\
8152 return 1 if the point is to be included in the shade plot and 0\n\
8153 otherwise. If you want to plot the entire shade plot (the usual\n\
8154 case), this argument should be set to NULL.\n\
8155 \n\
8156 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8157 pltr below for how these arguments are used (only for the special case\n\
8158 when the callback function\n\
8159 pltr is not supplied).\n\
8160 \n\
8161 clevel (PLFLT_VECTOR, input) : A vector containing the data levels\n\
8162 corresponding to the edges of each shaded region that will be\n\
8163 plotted by this function. To work properly the levels should be\n\
8164 monotonic.\n\
8165 \n\
8166 nlevel (PLINT, input) : Number of shades plus 1 (i.e., the number\n\
8167 of shade edge values in clevel).\n\
8168 \n\
8169 fill_width (PLFLT, input) : Defines the line width used by the fill\n\
8170 pattern.\n\
8171 \n\
8172 cont_color (PLINT, input) : Defines cmap0 pen color used for\n\
8173 contours defining edges of shaded regions. The pen color is only\n\
8174 temporary set for the contour drawing. Set this value to zero or\n\
8175 less if no shade edge contours are wanted.\n\
8176 \n\
8177 cont_width (PLFLT, input) : Defines line width used for contours\n\
8178 defining edges of shaded regions. This value may not be honored\n\
8179 by all drivers. The pen width is only temporary set for the\n\
8180 contour drawing. Set this value to zero or less if no shade edge\n\
8181 contours are wanted.\n\
8182 \n\
8183 fill (PLFILL_callback, input) : Callback routine used to fill the\n\
8184 region. Use plfill for this purpose.\n\
8185 \n\
8186 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8187 map to rectangles after coordinate transformation with pltrl.\n\
8188 Otherwise, set rectangular to false. If rectangular is set to\n\
8189 true, plshade tries to save time by filling large rectangles.\n\
8190 This optimization fails if the coordinate transformation distorts\n\
8191 the shape of rectangles. For example a plot in polar coordinates\n\
8192 has to have rectangular set to false.\n\
8193 \n\
8194 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8195 defines the transformation between the zero-based indices of the\n\
8196 matrix a and world coordinates. If\n\
8197 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8198 indices of a are mapped to the range\n\
8199 xmin through\n\
8200 xmax and the y indices of a are mapped to the range\n\
8201 ymin through\n\
8202 ymax.For the C case, transformation functions are provided in the\n\
8203 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8204 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8205 matrices. In addition, C callback routines for the transformation\n\
8206 can be supplied by the user such as the mypltr function in\n\
8207 examples/c/x09c.c which provides a general linear transformation\n\
8208 between index coordinates and world coordinates.For languages\n\
8209 other than C you should consult the PLplot documentation for the\n\
8210 details concerning how PLTRANSFORM_callback arguments are\n\
8211 interfaced. However, in general, a particular pattern of\n\
8212 callback-associated arguments such as a tr vector with 6 elements;\n\
8213 xg and yg vectors; or xg and yg matrices are respectively\n\
8214 interfaced to a linear-transformation routine similar to the above\n\
8215 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8216 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8217 support native language callbacks for handling index to\n\
8218 world-coordinate transformations. Examples of these various\n\
8219 approaches are given in examples/<language>x09*,\n\
8220 examples/<language>x16*, examples/<language>x20*,\n\
8221 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8222 supported languages.\n\
8223 \n\
8224 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8225 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8226 externally supplied.\n\
8227 ";
8228 static const char* _wrap_plcolorbar_texinfo = "-*- texinfo -*-\n\
8229 Plot color bar for image, shade or gradient plots\n\
8230 \n\
8231 DESCRIPTION:\n\
8232 \n\
8233 Routine for creating a continuous color bar for image, shade, or\n\
8234 gradient plots. (See pllegend for similar functionality for creating\n\
8235 legends with discrete elements). The arguments of plcolorbar provide\n\
8236 control over the location and size of the color bar as well as the\n\
8237 location and characteristics of the elements (most of which are\n\
8238 optional) within that color bar. The resulting color bar is clipped\n\
8239 at the boundaries of the current subpage. (N.B. the adopted coordinate\n\
8240 system used for some of the parameters is defined in the documentation\n\
8241 of the position parameter.)\n\
8242 \n\
8243 Redacted form: plcolorbar(p_colorbar_width, p_colorbar_height, opt,\n\
8244 position, x, y, x_length, y_length, bg_color, bb_color, bb_style,\n\
8245 low_cap_color, high_cap_color, cont_color, cont_width, label_opts,\n\
8246 labels, axis_opts, ticks, sub_ticks, values)\n\
8247 \n\
8248 This function is used in examples 16 and 33.\n\
8249 \n\
8250 \n\
8251 \n\
8252 SYNOPSIS:\n\
8253 \n\
8254 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\
8255 \n\
8256 ARGUMENTS:\n\
8257 \n\
8258 p_colorbar_width (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8259 labelled and decorated color bar width in adopted coordinates.\n\
8260 \n\
8261 p_colorbar_height (PLFLT_NC_SCALAR, output) : Returned value of the\n\
8262 labelled and decorated color bar height in adopted coordinates.\n\
8263 \n\
8264 opt (PLINT, input) : opt contains bits controlling the overall\n\
8265 color bar. The orientation (direction of the maximum value) of\n\
8266 the color bar is specified with PL_ORIENT_RIGHT, PL_ORIENT_TOP,\n\
8267 PL_ORIENT_LEFT, or PL_ORIENT_BOTTOM. If none of these bits are\n\
8268 specified, the default orientation is toward the top if the\n\
8269 colorbar is placed on the left or right of the viewport or toward\n\
8270 the right if the colorbar is placed on the top or bottom of the\n\
8271 viewport. If the PL_COLORBAR_BACKGROUND bit is set, plot a\n\
8272 (semitransparent) background for the color bar. If the\n\
8273 PL_COLORBAR_BOUNDING_BOX bit is set, plot a bounding box for the\n\
8274 color bar. The type of color bar must be specified with one of\n\
8275 PL_COLORBAR_IMAGE, PL_COLORBAR_SHADE, or PL_COLORBAR_GRADIENT. If\n\
8276 more than one of those bits is set only the first one in the above\n\
8277 list is honored. The position of the (optional) label/title can be\n\
8278 specified with PL_LABEL_RIGHT, PL_LABEL_TOP, PL_LABEL_LEFT, or\n\
8279 PL_LABEL_BOTTOM. If no label position bit is set then no label\n\
8280 will be drawn. If more than one of this list of bits is specified,\n\
8281 only the first one on the list is honored. End-caps for the color\n\
8282 bar can added with PL_COLORBAR_CAP_LOW and PL_COLORBAR_CAP_HIGH.\n\
8283 If a particular color bar cap option is not specified then no cap\n\
8284 will be drawn for that end. As a special case for\n\
8285 PL_COLORBAR_SHADE, the option PL_COLORBAR_SHADE_LABEL can be\n\
8286 specified. If this option is provided then any tick marks and tick\n\
8287 labels will be placed at the breaks between shaded segments. TODO:\n\
8288 This should be expanded to support custom placement of tick marks\n\
8289 and tick labels at custom value locations for any color bar type.\n\
8290 \n\
8291 position (PLINT, input) : position contains bits which control the\n\
8292 overall position of the color bar and the definition of the\n\
8293 adopted coordinates used for positions just like what is done for\n\
8294 the position argument for pllegend. However, note that the\n\
8295 defaults for the position bits (see below) are different than the\n\
8296 pllegend case. The combination of the PL_POSITION_LEFT,\n\
8297 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
8298 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
8299 the 16 possible standard positions (the 4 corners and centers of\n\
8300 the 4 sides for both the inside and outside cases) of the color\n\
8301 bar relative to the adopted coordinate system. The corner\n\
8302 positions are specified by the appropriate combination of two of\n\
8303 the PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
8304 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
8305 value of one of those bits. The adopted coordinates are\n\
8306 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
8307 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
8308 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
8309 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
8310 then use PL_POSITION_RIGHT. If neither of PL_POSITION_INSIDE or\n\
8311 PL_POSITION_OUTSIDE is set, use PL_POSITION_OUTSIDE. If neither of\n\
8312 PL_POSITION_VIEWPORT or PL_POSITION_SUBPAGE is set, use\n\
8313 PL_POSITION_VIEWPORT.\n\
8314 \n\
8315 x (PLFLT, input) : X offset of the color bar position in adopted\n\
8316 coordinates from the specified standard position of the color bar.\n\
8317 For positive x, the direction of motion away from the standard\n\
8318 position is inward/outward from the standard corner positions or\n\
8319 standard left or right positions if the\n\
8320 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8321 For the standard top or bottom positions, the direction of motion\n\
8322 is toward positive X.\n\
8323 \n\
8324 y (PLFLT, input) : Y offset of the color bar position in adopted\n\
8325 coordinates from the specified standard position of the color bar.\n\
8326 For positive y, the direction of motion away from the standard\n\
8327 position is inward/outward from the standard corner positions or\n\
8328 standard top or bottom positions if the\n\
8329 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position.\n\
8330 For the standard left or right positions, the direction of motion\n\
8331 is toward positive Y.\n\
8332 \n\
8333 x_length (PLFLT, input) : Length of the body of the color bar in\n\
8334 the X direction in adopted coordinates.\n\
8335 \n\
8336 y_length (PLFLT, input) : Length of the body of the color bar in\n\
8337 the Y direction in adopted coordinates.\n\
8338 \n\
8339 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
8340 color bar (PL_COLORBAR_BACKGROUND).\n\
8341 \n\
8342 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
8343 for the color bar (PL_COLORBAR_BOUNDING_BOX).\n\
8344 \n\
8345 bb_style (PLINT, input) : The pllsty style number for the\n\
8346 bounding-box line for the color bar (PL_COLORBAR_BACKGROUND).\n\
8347 \n\
8348 low_cap_color (PLFLT, input) : The cmap1 color of the low-end color\n\
8349 bar cap, if it is drawn (PL_COLORBAR_CAP_LOW).\n\
8350 \n\
8351 high_cap_color (PLFLT, input) : The cmap1 color of the high-end\n\
8352 color bar cap, if it is drawn (PL_COLORBAR_CAP_HIGH).\n\
8353 \n\
8354 cont_color (PLINT, input) : The cmap0 contour color for\n\
8355 PL_COLORBAR_SHADE plots. This is passed directly to plshades, so\n\
8356 it will be interpreted according to the design of plshades.\n\
8357 \n\
8358 cont_width (PLFLT, input) : Contour width for PL_COLORBAR_SHADE\n\
8359 plots. This is passed directly to plshades, so it will be\n\
8360 interpreted according to the design of plshades.\n\
8361 \n\
8362 n_labels (PLINT, input) : Number of labels to place around the\n\
8363 color bar.\n\
8364 \n\
8365 label_opts (PLINT_VECTOR, input) : A vector of options for each of\n\
8366 n_labels labels.\n\
8367 \n\
8368 labels (PLCHAR_MATRIX, input) : A vector of\n\
8369 n_labels UTF-8 character strings containing the labels for the color\n\
8370 bar. Ignored if no label position is specified with one of the\n\
8371 PL_COLORBAR_LABEL_RIGHT, PL_COLORBAR_LABEL_TOP,\n\
8372 PL_COLORBAR_LABEL_LEFT, or PL_COLORBAR_LABEL_BOTTOM bits in the\n\
8373 corresponding label_opts field.\n\
8374 \n\
8375 n_axes (PLINT, input) : Number of axis definitions provided. This\n\
8376 value must be greater than 0. It is typically 1 (numerical axis\n\
8377 labels are provided for one of the long edges of the color bar),\n\
8378 but it can be larger if multiple numerical axis labels for the\n\
8379 long edges of the color bar are desired.\n\
8380 \n\
8381 axis_opts (PLCHAR_MATRIX, input) : A vector of\n\
8382 n_axes ascii character strings containing options (interpreted as for\n\
8383 plbox) for the color bar\'s axis definitions.\n\
8384 \n\
8385 ticks (PLFLT_VECTOR, input) : A vector of n_axes values of the\n\
8386 spacing of the major tick marks (interpreted as for plbox) for the\n\
8387 color bar\'s axis definitions.\n\
8388 \n\
8389 sub_ticks (PLINT_VECTOR, input) : A vector of n_axes values of the\n\
8390 number of subticks (interpreted as for plbox) for the color bar\'s\n\
8391 axis definitions.\n\
8392 \n\
8393 n_values (PLINT_VECTOR, input) : A vector containing the number of\n\
8394 elements in each of the n_axes rows of the values matrix.\n\
8395 \n\
8396 values (PLFLT_MATRIX, input) : A matrix containing the numeric\n\
8397 values for the data range represented by the color bar. For a row\n\
8398 index of i_axis (where 0 < i_axis < n_axes), the number of\n\
8399 elements in the row is specified by n_values[i_axis]. For\n\
8400 PL_COLORBAR_IMAGE and PL_COLORBAR_GRADIENT the number of elements\n\
8401 is 2, and the corresponding row elements of the values matrix are\n\
8402 the minimum and maximum value represented by the colorbar. For\n\
8403 PL_COLORBAR_SHADE, the number and values of the elements of a row\n\
8404 of the values matrix is interpreted the same as the nlevel and\n\
8405 clevel arguments of plshades.\n\
8406 ";
8407 static const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
8408 Get current subpage parameters\n\
8409 \n\
8410 DESCRIPTION:\n\
8411 \n\
8412 Gets the size of the current subpage in millimeters measured from the\n\
8413 bottom left hand corner of the output device page or screen. Can be\n\
8414 used in conjunction with plsvpa for setting the size of a viewport in\n\
8415 absolute coordinates (millimeters).\n\
8416 \n\
8417 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
8418 \n\
8419 This function is used in example 23.\n\
8420 \n\
8421 \n\
8422 \n\
8423 SYNOPSIS:\n\
8424 \n\
8425 plgspa(xmin, xmax, ymin, ymax)\n\
8426 \n\
8427 ARGUMENTS:\n\
8428 \n\
8429 xmin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8430 the left hand edge of the subpage in millimeters.\n\
8431 \n\
8432 xmax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8433 the right hand edge of the subpage in millimeters.\n\
8434 \n\
8435 ymin (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8436 the bottom edge of the subpage in millimeters.\n\
8437 \n\
8438 ymax (PLFLT_NC_SCALAR, output) : Returned value of the position of\n\
8439 the top edge of the subpage in millimeters.\n\
8440 ";
8441 static const char* _wrap_plshade_texinfo = "-*- texinfo -*-\n\
8442 Shade individual region on the basis of value\n\
8443 \n\
8444 DESCRIPTION:\n\
8445 \n\
8446 Shade individual region on the basis of value. Use plshades if you\n\
8447 want to shade a number of contiguous regions using continuous colors.\n\
8448 In particular the edge contours are treated properly in plshades. If\n\
8449 you attempt to do contiguous regions with plshade the contours at the\n\
8450 edge of the shade are partially obliterated by subsequent plots of\n\
8451 contiguous shaded regions.\n\
8452 \n\
8453 Redacted form: General: plshade(a, defined, xmin, xmax, ymin, ymax,\n\
8454 shade_min, shade_max, sh_cmap, sh_color, sh_width, min_color,\n\
8455 min_width, max_color, max_width, fill, rectangular, pltr, pltr_data)\n\
8456 \n\
8457 \n\
8458 This function is used in example 15.\n\
8459 \n\
8460 \n\
8461 \n\
8462 SYNOPSIS:\n\
8463 \n\
8464 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\
8465 \n\
8466 ARGUMENTS:\n\
8467 \n\
8468 a (PLFLT_MATRIX, input) : A matrix containing function values to\n\
8469 plot. Should have dimensions of\n\
8470 nx by\n\
8471 ny.\n\
8472 \n\
8473 nx (PLINT, input) : First dimension of the matrix \"a\".\n\
8474 \n\
8475 ny (PLINT, input) : Second dimension of the matrix \"a\".\n\
8476 \n\
8477 defined (PLDEFINED_callback, input) : Callback function specifying\n\
8478 the region that should be plotted in the shade plot. This\n\
8479 function accepts x and y coordinates as input arguments and must\n\
8480 return 1 if the point is to be included in the shade plot and 0\n\
8481 otherwise. If you want to plot the entire shade plot (the usual\n\
8482 case), this argument should be set to NULL.\n\
8483 \n\
8484 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
8485 pltr below for how these arguments are used (only for the special case\n\
8486 when the callback function\n\
8487 pltr is not supplied).\n\
8488 \n\
8489 shade_min (PLFLT, input) : Defines the lower end of the interval to\n\
8490 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8491 \n\
8492 shade_max (PLFLT, input) : Defines the upper end of the interval to\n\
8493 be shaded. If shade_max <= shade_min, plshade does nothing.\n\
8494 \n\
8495 sh_cmap (PLINT, input) : Defines color map. If sh_cmap=0, then\n\
8496 sh_color is interpreted as a cmap0 (integer) index. If sh_cmap=1,\n\
8497 then sh_color is interpreted as a cmap1 argument in the range\n\
8498 (0.0-1.0).\n\
8499 \n\
8500 sh_color (PLFLT, input) : Defines color map index with integer\n\
8501 value if cmap0 or value in range (0.0-1.0) if cmap1.\n\
8502 \n\
8503 sh_width (PLFLT, input) : Defines width used by the fill pattern.\n\
8504 \n\
8505 min_color (PLINT, input) : Defines pen color, width used by the\n\
8506 boundary of shaded region. The min values are used for the\n\
8507 shade_min boundary, and the max values are used on the shade_max\n\
8508 boundary. Set color and width to zero for no plotted boundaries.\n\
8509 \n\
8510 min_width (PLFLT, input) : Defines pen color, width used by the\n\
8511 boundary of shaded region. The min values are used for the\n\
8512 shade_min boundary, and the max values are used on the shade_max\n\
8513 boundary. Set color and width to zero for no plotted boundaries.\n\
8514 \n\
8515 max_color (PLINT, input) : Defines pen color, width used by the\n\
8516 boundary of shaded region. The min values are used for the\n\
8517 shade_min boundary, and the max values are used on the shade_max\n\
8518 boundary. Set color and width to zero for no plotted boundaries.\n\
8519 \n\
8520 max_width (PLFLT, input) : Defines pen color, width used by the\n\
8521 boundary of shaded region. The min values are used for the\n\
8522 shade_min boundary, and the max values are used on the shade_max\n\
8523 boundary. Set color and width to zero for no plotted boundaries.\n\
8524 \n\
8525 fill (PLFILL_callback, input) : Routine used to fill the region.\n\
8526 Use plfill. Future version of PLplot may have other fill\n\
8527 routines.\n\
8528 \n\
8529 rectangular (PLBOOL, input) : Set rectangular to true if rectangles\n\
8530 map to rectangles after coordinate transformation with pltrl.\n\
8531 Otherwise, set rectangular to false. If rectangular is set to\n\
8532 true, plshade tries to save time by filling large rectangles.\n\
8533 This optimization fails if the coordinate transformation distorts\n\
8534 the shape of rectangles. For example a plot in polar coordinates\n\
8535 has to have rectangular set to false.\n\
8536 \n\
8537 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
8538 defines the transformation between the zero-based indices of the\n\
8539 matrix a and world coordinates. If\n\
8540 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
8541 indices of a are mapped to the range\n\
8542 xmin through\n\
8543 xmax and the y indices of a are mapped to the range\n\
8544 ymin through\n\
8545 ymax.For the C case, transformation functions are provided in the\n\
8546 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
8547 pltr2 for arbitrary mappings respectively defined by vectors and\n\
8548 matrices. In addition, C callback routines for the transformation\n\
8549 can be supplied by the user such as the mypltr function in\n\
8550 examples/c/x09c.c which provides a general linear transformation\n\
8551 between index coordinates and world coordinates.For languages\n\
8552 other than C you should consult the PLplot documentation for the\n\
8553 details concerning how PLTRANSFORM_callback arguments are\n\
8554 interfaced. However, in general, a particular pattern of\n\
8555 callback-associated arguments such as a tr vector with 6 elements;\n\
8556 xg and yg vectors; or xg and yg matrices are respectively\n\
8557 interfaced to a linear-transformation routine similar to the above\n\
8558 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
8559 sophisticated bindings (see, e.g., the PLplot documentation)\n\
8560 support native language callbacks for handling index to\n\
8561 world-coordinate transformations. Examples of these various\n\
8562 approaches are given in examples/<language>x09*,\n\
8563 examples/<language>x16*, examples/<language>x20*,\n\
8564 examples/<language>x21*, and examples/<language>x22*, for all our\n\
8565 supported languages.\n\
8566 \n\
8567 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
8568 information to pltr0, pltr1, pltr2, or whatever routine that is\n\
8569 externally supplied.\n\
8570 ";
8571 static const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
8572 Calculate world coordinates and corresponding window index from relative device coordinates\n\
8573 \n\
8574 DESCRIPTION:\n\
8575 \n\
8576 Calculate world coordinates, wx and wy, and corresponding window index\n\
8577 from relative device coordinates, rx and ry.\n\
8578 \n\
8579 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
8580 \n\
8581 \n\
8582 This function is used in example 31.\n\
8583 \n\
8584 \n\
8585 \n\
8586 SYNOPSIS:\n\
8587 \n\
8588 plcalc_world(rx, ry, wx, wy, window)\n\
8589 \n\
8590 ARGUMENTS:\n\
8591 \n\
8592 rx (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8593 the x coordinate.\n\
8594 \n\
8595 ry (PLFLT, input) : Input relative device coordinate (0.0-1.0) for\n\
8596 the y coordinate.\n\
8597 \n\
8598 wx (PLFLT_NC_SCALAR, output) : Returned value of the x world\n\
8599 coordinate corresponding to the relative device coordinates rx and\n\
8600 ry.\n\
8601 \n\
8602 wy (PLFLT_NC_SCALAR, output) : Returned value of the y world\n\
8603 coordinate corresponding to the relative device coordinates rx and\n\
8604 ry.\n\
8605 \n\
8606 window (PLINT_NC_SCALAR, output) : Returned value of the last\n\
8607 defined window index that corresponds to the input relative device\n\
8608 coordinates (and the returned world coordinates). To give some\n\
8609 background on the window index, for each page the initial window\n\
8610 index is set to zero, and each time plwind is called within the\n\
8611 page, world and device coordinates are stored for the window and\n\
8612 the window index is incremented. Thus, for a simple page layout\n\
8613 with non-overlapping viewports and one window per viewport, window\n\
8614 corresponds to the viewport index (in the order which the\n\
8615 viewport/windows were created) of the only viewport/window\n\
8616 corresponding to rx and ry. However, for more complicated layouts\n\
8617 with potentially overlapping viewports and possibly more than one\n\
8618 window (set of world coordinates) per viewport, window and the\n\
8619 corresponding output world coordinates corresponds to the last\n\
8620 window created that fulfills the criterion that the relative\n\
8621 device coordinates are inside it. Finally, in all cases where the\n\
8622 input relative device coordinates are not inside any\n\
8623 viewport/window, then the returned value of the last defined\n\
8624 window index is set to -1.\n\
8625 ";
8626 static const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
8627 Draw a box with axes, etc, in 3-d\n\
8628 \n\
8629 DESCRIPTION:\n\
8630 \n\
8631 Draws axes, numeric and text labels for a three-dimensional surface\n\
8632 plot. For a more complete description of three-dimensional plotting\n\
8633 see the PLplot documentation.\n\
8634 \n\
8635 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
8636 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8637 \n\
8638 \n\
8639 This function is used in examples 8, 11, 18, and 21.\n\
8640 \n\
8641 \n\
8642 \n\
8643 SYNOPSIS:\n\
8644 \n\
8645 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
8646 \n\
8647 ARGUMENTS:\n\
8648 \n\
8649 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8650 options for the x axis. The string can include any combination of\n\
8651 the following letters (upper or lower case) in any order: b: Draws\n\
8652 axis at base, at height z=\n\
8653 zmin where zmin is defined by call to plw3d. This character must be\n\
8654 specified in order to use any of the other options.\n\
8655 d: Plot labels as date / time. Values are assumed to be\n\
8656 seconds since the epoch (as used by gmtime).\n\
8657 f: Always use fixed point numeric labels.\n\
8658 i: Inverts tick marks, so they are drawn downwards, rather\n\
8659 than upwards.\n\
8660 l: Labels axis logarithmically. This only affects the labels,\n\
8661 not the data, and so it is necessary to compute the logarithms\n\
8662 of data points before passing them to any of the drawing\n\
8663 routines.\n\
8664 n: Writes numeric labels at major tick intervals.\n\
8665 o: Use custom labelling function to generate axis label text.\n\
8666 The custom labelling function can be defined with the\n\
8667 plslabelfunc command.\n\
8668 s: Enables subticks between major ticks, only valid if t is\n\
8669 also specified.\n\
8670 t: Draws major ticks.\n\
8671 u: If this is specified, the text label for the axis is\n\
8672 written under the axis.\n\
8673 \n\
8674 \n\
8675 xlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8676 the text label for the x axis. It is only drawn if u is in the\n\
8677 xopt string.\n\
8678 \n\
8679 xtick (PLFLT, input) : World coordinate interval between major\n\
8680 ticks on the x axis. If it is set to zero, PLplot automatically\n\
8681 generates a suitable tick interval.\n\
8682 \n\
8683 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
8684 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8685 generates a suitable minor tick interval.\n\
8686 \n\
8687 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8688 options for the y axis. The string is interpreted in the same way\n\
8689 as xopt.\n\
8690 \n\
8691 ylabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8692 the text label for the y axis. It is only drawn if u is in the\n\
8693 yopt string.\n\
8694 \n\
8695 ytick (PLFLT, input) : World coordinate interval between major\n\
8696 ticks on the y axis. If it is set to zero, PLplot automatically\n\
8697 generates a suitable tick interval.\n\
8698 \n\
8699 nysub (PLINT, input) : Number of subintervals between major y axis\n\
8700 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8701 generates a suitable minor tick interval.\n\
8702 \n\
8703 zopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
8704 options for the z axis. The string can include any combination of\n\
8705 the following letters (upper or lower case) in any order: b: Draws\n\
8706 z axis to the left of the surface plot.\n\
8707 c: Draws z axis to the right of the surface plot.\n\
8708 d: Draws grid lines parallel to the x-y plane behind the\n\
8709 figure. These lines are not drawn until after plot3d or\n\
8710 plmesh are called because of the need for hidden line removal.\n\
8711 e: Plot labels as date / time. Values are assumed to be\n\
8712 seconds since the epoch (as used by gmtime). Note this\n\
8713 suboption is interpreted the same as the d suboption for xopt\n\
8714 and yopt, but it has to be identified as e for zopt since d\n\
8715 has already been used for the different purpose above.\n\
8716 f: Always use fixed point numeric labels.\n\
8717 i: Inverts tick marks, so they are drawn away from the center.\n\
8718 l: Labels axis logarithmically. This only affects the labels,\n\
8719 not the data, and so it is necessary to compute the logarithms\n\
8720 of data points before passing them to any of the drawing\n\
8721 routines.\n\
8722 m: Writes numeric labels at major tick intervals on the\n\
8723 right-hand z axis.\n\
8724 n: Writes numeric labels at major tick intervals on the\n\
8725 left-hand z axis.\n\
8726 o: Use custom labelling function to generate axis label text.\n\
8727 The custom labelling function can be defined with the\n\
8728 plslabelfunc command.\n\
8729 s: Enables subticks between major ticks, only valid if t is\n\
8730 also specified.\n\
8731 t: Draws major ticks.\n\
8732 u: If this is specified, the text label is written beside the\n\
8733 left-hand axis.\n\
8734 v: If this is specified, the text label is written beside the\n\
8735 right-hand axis.\n\
8736 \n\
8737 \n\
8738 zlabel (PLCHAR_VECTOR, input) : A UTF-8 character string specifying\n\
8739 the text label for the z axis. It is only drawn if u or v are in\n\
8740 the zopt string.\n\
8741 \n\
8742 ztick (PLFLT, input) : World coordinate interval between major\n\
8743 ticks on the z axis. If it is set to zero, PLplot automatically\n\
8744 generates a suitable tick interval.\n\
8745 \n\
8746 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
8747 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
8748 generates a suitable minor tick interval.\n\
8749 ";
8750 static const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
8751 Get character default height and current (scaled) height\n\
8752 \n\
8753 DESCRIPTION:\n\
8754 \n\
8755 Get character default height and current (scaled) height.\n\
8756 \n\
8757 Redacted form: plgchr(p_def, p_ht)\n\
8758 \n\
8759 This function is used in example 23.\n\
8760 \n\
8761 \n\
8762 \n\
8763 SYNOPSIS:\n\
8764 \n\
8765 plgchr(p_def, p_ht)\n\
8766 \n\
8767 ARGUMENTS:\n\
8768 \n\
8769 p_def (PLFLT_NC_SCALAR, output) : Returned value of the default\n\
8770 character height (mm).\n\
8771 \n\
8772 p_ht (PLFLT_NC_SCALAR, output) : Returned value of the scaled\n\
8773 character height (mm).\n\
8774 ";
8775 static const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
8776 Set the escape character for text strings\n\
8777 \n\
8778 DESCRIPTION:\n\
8779 \n\
8780 Set the escape character for text strings. From C (in contrast to\n\
8781 Fortran, see plsescfortran) you pass esc as a character. Only selected\n\
8782 characters are allowed to prevent the user from shooting himself in\n\
8783 the foot (For example, a \\ isn\'t allowed since it conflicts with C\'s\n\
8784 use of backslash as a character escape). Here are the allowed escape\n\
8785 characters and their corresponding decimal ASCII values: !, ASCII 33\n\
8786 #, ASCII 35\n\
8787 $, ASCII 36\n\
8788 %, ASCII 37\n\
8789 &, ASCII 38\n\
8790 *, ASCII 42\n\
8791 @, ASCII 64\n\
8792 ^, ASCII 94\n\
8793 ~, ASCII 126\n\
8794 \n\
8795 \n\
8796 Redacted form: General: plsesc(esc)\n\
8797 \n\
8798 \n\
8799 This function is used in example 29.\n\
8800 \n\
8801 \n\
8802 \n\
8803 SYNOPSIS:\n\
8804 \n\
8805 plsesc(esc)\n\
8806 \n\
8807 ARGUMENTS:\n\
8808 \n\
8809 esc (char, input) : Escape character.\n\
8810 ";
8811 static const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
8812 Draw a line between two points, accounting for coordinate transforms\n\
8813 \n\
8814 DESCRIPTION:\n\
8815 \n\
8816 Joins the point (\n\
8817 x1,\n\
8818 y1) to (\n\
8819 x2,\n\
8820 y2) . If a global coordinate transform is defined then the line is\n\
8821 broken in to n segments to approximate the path. If no transform is\n\
8822 defined then this simply acts like a call to pljoin.\n\
8823 \n\
8824 Redacted form: plpath(n,x1,y1,x2,y2)\n\
8825 \n\
8826 This function is used in example 22.\n\
8827 \n\
8828 \n\
8829 \n\
8830 SYNOPSIS:\n\
8831 \n\
8832 plpath(n, x1, y1, x2, y2)\n\
8833 \n\
8834 ARGUMENTS:\n\
8835 \n\
8836 n (PLINT, input) : number of points to use to approximate the path.\n\
8837 \n\
8838 x1 (PLFLT, input) : x coordinate of first point.\n\
8839 \n\
8840 y1 (PLFLT, input) : y coordinate of first point.\n\
8841 \n\
8842 x2 (PLFLT, input) : x coordinate of second point.\n\
8843 \n\
8844 y2 (PLFLT, input) : y coordinate of second point.\n\
8845 ";
8846 static const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
8847 Set up standard window and draw box\n\
8848 \n\
8849 DESCRIPTION:\n\
8850 \n\
8851 Sets up plotter environment for simple graphs by calling pladv and\n\
8852 setting up viewport and window to sensible default values. plenv\n\
8853 leaves a standard margin (left-hand margin of eight character heights,\n\
8854 and a margin around the other three sides of five character heights)\n\
8855 around most graphs for axis labels and a title. When these defaults\n\
8856 are not suitable, use the individual routines plvpas, plvpor, or\n\
8857 plvasp for setting up the viewport, plwind for defining the window,\n\
8858 and plbox for drawing the box.\n\
8859 \n\
8860 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8861 \n\
8862 This function is used in example 1,3,9,13,14,19-22,29.\n\
8863 \n\
8864 \n\
8865 \n\
8866 SYNOPSIS:\n\
8867 \n\
8868 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
8869 \n\
8870 ARGUMENTS:\n\
8871 \n\
8872 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
8873 world coordinates).\n\
8874 \n\
8875 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
8876 world coordinates).\n\
8877 \n\
8878 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
8879 coordinates).\n\
8880 \n\
8881 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
8882 coordinates).\n\
8883 \n\
8884 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
8885 scales will not be set, the user must set up the scale before\n\
8886 calling plenv using plsvpa, plvasp or other.\n\
8887 0: the x and y axes are scaled independently to use as much of\n\
8888 the screen as possible.\n\
8889 1: the scales of the x and y axes are made equal.\n\
8890 2: the axis of the x and y axes are made equal, and the plot\n\
8891 box will be square.\n\
8892 \n\
8893 \n\
8894 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
8895 -2: draw no box, no tick marks, no numeric tick labels, no axes.\n\
8896 -1: draw box only.\n\
8897 0: draw box, ticks, and numeric tick labels.\n\
8898 1: also draw coordinate axes at x=0 and y=0.\n\
8899 2: also draw a grid at major tick positions in both\n\
8900 coordinates.\n\
8901 3: also draw a grid at minor tick positions in both\n\
8902 coordinates.\n\
8903 10: same as 0 except logarithmic x tick marks. (The x data\n\
8904 have to be converted to logarithms separately.)\n\
8905 11: same as 1 except logarithmic x tick marks. (The x data\n\
8906 have to be converted to logarithms separately.)\n\
8907 12: same as 2 except logarithmic x tick marks. (The x data\n\
8908 have to be converted to logarithms separately.)\n\
8909 13: same as 3 except logarithmic x tick marks. (The x data\n\
8910 have to be converted to logarithms separately.)\n\
8911 20: same as 0 except logarithmic y tick marks. (The y data\n\
8912 have to be converted to logarithms separately.)\n\
8913 21: same as 1 except logarithmic y tick marks. (The y data\n\
8914 have to be converted to logarithms separately.)\n\
8915 22: same as 2 except logarithmic y tick marks. (The y data\n\
8916 have to be converted to logarithms separately.)\n\
8917 23: same as 3 except logarithmic y tick marks. (The y data\n\
8918 have to be converted to logarithms separately.)\n\
8919 30: same as 0 except logarithmic x and y tick marks. (The x\n\
8920 and y data have to be converted to logarithms separately.)\n\
8921 31: same as 1 except logarithmic x and y tick marks. (The x\n\
8922 and y data have to be converted to logarithms separately.)\n\
8923 32: same as 2 except logarithmic x and y tick marks. (The x\n\
8924 and y data have to be converted to logarithms separately.)\n\
8925 33: same as 3 except logarithmic x and y tick marks. (The x\n\
8926 and y data have to be converted to logarithms separately.)\n\
8927 40: same as 0 except date / time x labels.\n\
8928 41: same as 1 except date / time x labels.\n\
8929 42: same as 2 except date / time x labels.\n\
8930 43: same as 3 except date / time x labels.\n\
8931 50: same as 0 except date / time y labels.\n\
8932 51: same as 1 except date / time y labels.\n\
8933 52: same as 2 except date / time y labels.\n\
8934 53: same as 3 except date / time y labels.\n\
8935 60: same as 0 except date / time x and y labels.\n\
8936 61: same as 1 except date / time x and y labels.\n\
8937 62: same as 2 except date / time x and y labels.\n\
8938 63: same as 3 except date / time x and y labels.\n\
8939 70: same as 0 except custom x and y labels.\n\
8940 71: same as 1 except custom x and y labels.\n\
8941 72: same as 2 except custom x and y labels.\n\
8942 73: same as 3 except custom x and y labels.\n\
8943 ";
8944 static const char* _wrap_plgriddata_texinfo = "-*- texinfo -*-\n\
8945 Grid data from irregularly sampled data\n\
8946 \n\
8947 DESCRIPTION:\n\
8948 \n\
8949 Real world data is frequently irregularly sampled, but PLplot 3D plots\n\
8950 require data organized as a grid, i.e., with x sample point values\n\
8951 independent of y coordinate and vice versa. This function takes\n\
8952 irregularly sampled data from the x[npts], y[npts], and z[npts]\n\
8953 vectors; reads the desired grid location from the input vectors\n\
8954 xg[nptsx] and yg[nptsy]; and returns the interpolated result on that\n\
8955 grid using the output matrix zg[nptsx][nptsy]. The algorithm used to\n\
8956 interpolate the data to the grid is specified with the argument type\n\
8957 which can have one parameter specified in argument data.\n\
8958 \n\
8959 Redacted form: General: plgriddata(x, y, z, xg, yg, zg, type, data)\n\
8960 Python: zg=plgriddata(x, y, z, xg, yg, type, data)\n\
8961 \n\
8962 \n\
8963 This function is used in example 21.\n\
8964 \n\
8965 \n\
8966 \n\
8967 SYNOPSIS:\n\
8968 \n\
8969 plgriddata(x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data)\n\
8970 \n\
8971 ARGUMENTS:\n\
8972 \n\
8973 x (PLFLT_VECTOR, input) : The input x vector.\n\
8974 \n\
8975 y (PLFLT_VECTOR, input) : The input y vector.\n\
8976 \n\
8977 z (PLFLT_VECTOR, input) : The input z vector. Each triple x[i],\n\
8978 y[i], z[i] represents one data sample coordinate.\n\
8979 \n\
8980 npts (PLINT, input) : The number of data samples in the x, y and z\n\
8981 vectors.\n\
8982 \n\
8983 xg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8984 in the x direction. Usually xg has nptsx equally spaced values\n\
8985 from the minimum to the maximum values of the x input vector.\n\
8986 \n\
8987 nptsx (PLINT, input) : The number of points in the xg vector.\n\
8988 \n\
8989 yg (PLFLT_VECTOR, input) : A vector that specifies the grid spacing\n\
8990 in the y direction. Similar to the xg parameter.\n\
8991 \n\
8992 nptsy (PLINT, input) : The number of points in the yg vector.\n\
8993 \n\
8994 zg (PLFLT_NC_MATRIX, output) : The matrix of interpolated results\n\
8995 where data lies in the grid specified by xg and yg. Therefore the\n\
8996 zg matrix must be dimensioned\n\
8997 nptsx by\n\
8998 nptsy.\n\
8999 \n\
9000 type (PLINT, input) : The type of grid interpolation algorithm to\n\
9001 use, which can be: GRID_CSA: Bivariate Cubic Spline approximation\n\
9002 GRID_DTLI: Delaunay Triangulation Linear Interpolation\n\
9003 GRID_NNI: Natural Neighbors Interpolation\n\
9004 GRID_NNIDW: Nearest Neighbors Inverse Distance Weighted\n\
9005 GRID_NNLI: Nearest Neighbors Linear Interpolation\n\
9006 GRID_NNAIDW: Nearest Neighbors Around Inverse Distance\n\
9007 Weighted\n\
9008 For details of the algorithms read the source file plgridd.c.\n\
9009 \n\
9010 data (PLFLT, input) : Some gridding algorithms require extra data,\n\
9011 which can be specified through this argument. Currently, for\n\
9012 algorithm: GRID_NNIDW, data specifies the number of neighbors to\n\
9013 use, the lower the value, the noisier (more local) the\n\
9014 approximation is.\n\
9015 GRID_NNLI, data specifies what a thin triangle is, in the\n\
9016 range [1. .. 2.]. High values enable the usage of very thin\n\
9017 triangles for interpolation, possibly resulting in error in\n\
9018 the approximation.\n\
9019 GRID_NNI, only weights greater than data will be accepted. If\n\
9020 0, all weights will be accepted.\n\
9021 ";
9022 static const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
9023 Clear current (sub)page\n\
9024 \n\
9025 DESCRIPTION:\n\
9026 \n\
9027 Clears the current page, effectively erasing everything that have been\n\
9028 drawn. This command only works with interactive drivers; if the\n\
9029 driver does not support this, the page is filled with the background\n\
9030 color in use. If the current page is divided into subpages, only the\n\
9031 current subpage is erased. The nth subpage can be selected with\n\
9032 pladv(n).\n\
9033 \n\
9034 Redacted form: General: plclear()\n\
9035 \n\
9036 \n\
9037 This function is not used in any examples.\n\
9038 \n\
9039 \n\
9040 \n\
9041 SYNOPSIS:\n\
9042 \n\
9043 plclear()\n\
9044 ";
9045 static const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
9046 Set cmap0 colors by 8-bit RGB values and PLFLT alpha transparency value\n\
9047 \n\
9048 DESCRIPTION:\n\
9049 \n\
9050 Set cmap0 colors using 8-bit RGB values (see the PLplot documentation)\n\
9051 and PLFLT alpha transparency value. This sets the entire color map --\n\
9052 only as many colors as specified will be allocated.\n\
9053 \n\
9054 Redacted form: plscmap0a(r, g, b, alpha)\n\
9055 \n\
9056 This function is used in examples 30.\n\
9057 \n\
9058 \n\
9059 \n\
9060 SYNOPSIS:\n\
9061 \n\
9062 plscmap0a(r, g, b, alpha, ncol0)\n\
9063 \n\
9064 ARGUMENTS:\n\
9065 \n\
9066 r (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9067 integers (0-255) representing the degree of red in the color.\n\
9068 \n\
9069 g (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9070 integers (0-255) representing the degree of green in the color.\n\
9071 \n\
9072 b (PLINT_VECTOR, input) : A vector containing unsigned 8-bit\n\
9073 integers (0-255) representing the degree of blue in the color.\n\
9074 \n\
9075 alpha (PLFLT_VECTOR, input) : A vector containing values (0.0-1.0)\n\
9076 representing the alpha transparency of the color.\n\
9077 \n\
9078 ncol0 (PLINT, input) : Number of items in the r, g, b, and alpha\n\
9079 vectors.\n\
9080 ";
9081 static const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
9082 Set 8-bit RGB values for given cmap0 color index\n\
9083 \n\
9084 DESCRIPTION:\n\
9085 \n\
9086 Set 8-bit RGB values for given cmap0 (see the PLplot documentation)\n\
9087 index. Overwrites the previous color value for the given index and,\n\
9088 thus, does not result in any additional allocation of space for\n\
9089 colors.\n\
9090 \n\
9091 Redacted form: plscol0(icol0, r, g, b)\n\
9092 \n\
9093 This function is used in any example 31.\n\
9094 \n\
9095 \n\
9096 \n\
9097 SYNOPSIS:\n\
9098 \n\
9099 plscol0(icol0, r, g, b)\n\
9100 \n\
9101 ARGUMENTS:\n\
9102 \n\
9103 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
9104 number of colors (which is set by default, by plscmap0n, or even\n\
9105 by plscmap0).\n\
9106 \n\
9107 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9108 degree of red in the color.\n\
9109 \n\
9110 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9111 degree of green in the color.\n\
9112 \n\
9113 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9114 degree of blue in the color.\n\
9115 ";
9116 static const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
9117 Set up transformation from metafile coordinates\n\
9118 \n\
9119 DESCRIPTION:\n\
9120 \n\
9121 Set up transformation from metafile coordinates. The size of the plot\n\
9122 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
9123 general-purpose facility just yet (not sure why the user would need\n\
9124 it, for one).\n\
9125 \n\
9126 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
9127 dimypmm)\n\
9128 \n\
9129 This function is not used in any examples.\n\
9130 \n\
9131 \n\
9132 \n\
9133 SYNOPSIS:\n\
9134 \n\
9135 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
9136 \n\
9137 ARGUMENTS:\n\
9138 \n\
9139 dimxmin (PLINT, input) : NEEDS DOCUMENTATION\n\
9140 \n\
9141 dimxmax (PLINT, input) : NEEDS DOCUMENTATION\n\
9142 \n\
9143 dimymin (PLINT, input) : NEEDS DOCUMENTATION\n\
9144 \n\
9145 dimymax (PLINT, input) : NEEDS DOCUMENTATION\n\
9146 \n\
9147 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9148 \n\
9149 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION\n\
9150 ";
9151 static const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
9152 Creates a new stream and makes it the default\n\
9153 \n\
9154 DESCRIPTION:\n\
9155 \n\
9156 Creates a new stream and makes it the default. Differs from using\n\
9157 plsstrm, in that a free stream number is found, and returned.\n\
9158 Unfortunately, I have to start at stream 1 and work upward, since\n\
9159 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
9160 that no initial, library-opening call is required. So stream 0 must\n\
9161 be preallocated, and there is no simple way of determining whether it\n\
9162 is already in use or not.\n\
9163 \n\
9164 Redacted form: plmkstrm(p_strm)\n\
9165 \n\
9166 This function is used in examples 1 and 20.\n\
9167 \n\
9168 \n\
9169 \n\
9170 SYNOPSIS:\n\
9171 \n\
9172 plmkstrm(p_strm)\n\
9173 \n\
9174 ARGUMENTS:\n\
9175 \n\
9176 p_strm (PLINT_NC_SCALAR, output) : Returned value of the stream\n\
9177 number of the created stream.\n\
9178 ";
9179 static const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
9180 Get page parameters\n\
9181 \n\
9182 DESCRIPTION:\n\
9183 \n\
9184 Gets the current page configuration. The length and offset values are\n\
9185 expressed in units that are specific to the current driver. For\n\
9186 instance: screen drivers will usually interpret them as number of\n\
9187 pixels, whereas printer drivers will usually use mm.\n\
9188 \n\
9189 Redacted form: plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9190 \n\
9191 This function is used in examples 14 and 31.\n\
9192 \n\
9193 \n\
9194 \n\
9195 SYNOPSIS:\n\
9196 \n\
9197 plgpage(p_xp, p_yp, p_xleng, p_yleng, p_xoff, p_yoff)\n\
9198 \n\
9199 ARGUMENTS:\n\
9200 \n\
9201 p_xp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9202 pixels/inch (DPI) in x.\n\
9203 \n\
9204 p_yp (PLFLT_NC_SCALAR, output) : Returned value of the number of\n\
9205 pixels/inch (DPI) in y.\n\
9206 \n\
9207 p_xleng (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9208 length.\n\
9209 \n\
9210 p_yleng (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9211 length.\n\
9212 \n\
9213 p_xoff (PLINT_NC_SCALAR, output) : Returned value of the x page\n\
9214 offset.\n\
9215 \n\
9216 p_yoff (PLINT_NC_SCALAR, output) : Returned value of the y page\n\
9217 offset.\n\
9218 ";
9219 static const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
9220 Set format for date / time labels\n\
9221 \n\
9222 DESCRIPTION:\n\
9223 \n\
9224 Sets the format for date / time labels. To enable date / time format\n\
9225 labels see the options to plbox, plbox3, and plenv.\n\
9226 \n\
9227 Redacted form: pltimefmt(fmt)\n\
9228 \n\
9229 This function is used in example 29.\n\
9230 \n\
9231 \n\
9232 \n\
9233 SYNOPSIS:\n\
9234 \n\
9235 pltimefmt(fmt)\n\
9236 \n\
9237 ARGUMENTS:\n\
9238 \n\
9239 fmt (PLCHAR_VECTOR, input) : An ascii character string which is\n\
9240 interpreted similarly to the format specifier of typical system\n\
9241 strftime routines except that PLplot ignores locale and also\n\
9242 supplies some useful extensions in the context of plotting. All\n\
9243 text in the string is printed as-is other than conversion\n\
9244 specifications which take the form of a \'%\' character followed by\n\
9245 further conversion specification character. The conversion\n\
9246 specifications which are similar to those provided by system\n\
9247 strftime routines are the following: %a: The abbreviated (English)\n\
9248 weekday name.\n\
9249 %A: The full (English) weekday name.\n\
9250 %b: The abbreviated (English) month name.\n\
9251 %B: The full (English) month name.\n\
9252 %c: Equivalent to %a %b %d %T %Y (non-ISO).\n\
9253 %C: The century number (year/100) as a 2-digit integer.\n\
9254 %d: The day of the month as a decimal number (range 01 to 31).\n\
9255 %D: Equivalent to %m/%d/%y (non-ISO).\n\
9256 %e: Like %d, but a leading zero is replaced by a space.\n\
9257 %F: Equivalent to %Y-%m-%d (the ISO 8601 date format).\n\
9258 %h: Equivalent to %b.\n\
9259 %H: The hour as a decimal number using a 24-hour clock (range\n\
9260 00 to 23).\n\
9261 %I: The hour as a decimal number using a 12-hour clock (range\n\
9262 01 to 12).\n\
9263 %j: The day of the year as a decimal number (range 001 to\n\
9264 366).\n\
9265 %k: The hour (24-hour clock) as a decimal number (range 0 to\n\
9266 23); single digits are preceded by a blank. (See also %H.)\n\
9267 %l: The hour (12-hour clock) as a decimal number (range 1 to\n\
9268 12); single digits are preceded by a blank. (See also %I.)\n\
9269 %m: The month as a decimal number (range 01 to 12).\n\
9270 %M: The minute as a decimal number (range 00 to 59).\n\
9271 %n: A newline character.\n\
9272 %p: Either \"AM\" or \"PM\" according to the given time value.\n\
9273 Noon is treated as \"PM\" and midnight as \"AM\".\n\
9274 %r: Equivalent to %I:%M:%S %p.\n\
9275 %R: The time in 24-hour notation (%H:%M). For a version\n\
9276 including the seconds, see %T below.\n\
9277 %s: The number of seconds since the Epoch, 1970-01-01 00:00:00\n\
9278 +0000 (UTC).\n\
9279 %S: The second as a decimal number (range 00 to 60). (The\n\
9280 range is up to 60 to allow for occasional leap seconds.)\n\
9281 %t: A tab character.\n\
9282 %T: The time in 24-hour notation (%H:%M:%S).\n\
9283 %u: The day of the week as a decimal, range 1 to 7, Monday\n\
9284 being 1. See also %w.\n\
9285 %U: The week number of the current year as a decimal number,\n\
9286 range 00 to 53, starting with the first Sunday as the first\n\
9287 day of week 01. See also %V and %W.\n\
9288 %v: Equivalent to %e-%b-%Y.\n\
9289 %V: The ISO 8601 week number of the current year as a decimal\n\
9290 number, range 01 to 53, where week 1 is the first week that\n\
9291 has at least 4 days in the new year. See also %U and %W.\n\
9292 %w: The day of the week as a decimal, range 0 to 6, Sunday\n\
9293 being 0. See also %u.\n\
9294 %W: The week number of the current year as a decimal number,\n\
9295 range 00 to 53, starting with the first Monday as the first\n\
9296 day of week 01.\n\
9297 %x: Equivalent to %a %b %d %Y.\n\
9298 %X: Equivalent to %T.\n\
9299 %y: The year as a decimal number without a century (range 00\n\
9300 to 99).\n\
9301 %Y: The year as a decimal number including a century.\n\
9302 %z: The UTC time-zone string = \"+0000\".\n\
9303 %Z: The UTC time-zone abbreviation = \"UTC\".\n\
9304 %+: The UTC date and time in default format of the Unix date\n\
9305 command which is equivalent to %a %b %d %T %Z %Y.\n\
9306 %%: A literal \"%\" character.\n\
9307 The conversion specifications which are extensions to those normally\n\
9308 provided by system strftime routines are the following: %(0-9):\n\
9309 The fractional part of the seconds field (including leading\n\
9310 decimal point) to the specified accuracy. Thus %S%3 would give\n\
9311 seconds to millisecond accuracy (00.000).\n\
9312 %.: The fractional part of the seconds field (including\n\
9313 leading decimal point) to the maximum available accuracy. Thus\n\
9314 %S%. would give seconds with fractional part up to 9 decimal\n\
9315 places if available.\n\
9316 ";
9317 static const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
9318 Specify viewport using aspect ratio only\n\
9319 \n\
9320 DESCRIPTION:\n\
9321 \n\
9322 Selects the largest viewport with the given aspect ratio within the\n\
9323 subpage that leaves a standard margin (left-hand margin of eight\n\
9324 character heights, and a margin around the other three sides of five\n\
9325 character heights).\n\
9326 \n\
9327 Redacted form: plvasp(aspect)\n\
9328 \n\
9329 This function is used in example 13.\n\
9330 \n\
9331 \n\
9332 \n\
9333 SYNOPSIS:\n\
9334 \n\
9335 plvasp(aspect)\n\
9336 \n\
9337 ARGUMENTS:\n\
9338 \n\
9339 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
9340 axis of resulting viewport.\n\
9341 ";
9342 static const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
9343 Set output file name\n\
9344 \n\
9345 DESCRIPTION:\n\
9346 \n\
9347 Sets the current output file name, if applicable. If the file name\n\
9348 has not been specified and is required by the driver, the user will be\n\
9349 prompted for it. If using the X-windows output driver, this sets the\n\
9350 display name. This routine, if used, must be called before\n\
9351 initializing PLplot.\n\
9352 \n\
9353 Redacted form: plsfnam(fnam)\n\
9354 \n\
9355 This function is used in examples 1 and 20.\n\
9356 \n\
9357 \n\
9358 \n\
9359 SYNOPSIS:\n\
9360 \n\
9361 plsfnam(fnam)\n\
9362 \n\
9363 ARGUMENTS:\n\
9364 \n\
9365 fnam (PLCHAR_VECTOR, input) : An ascii character string containing\n\
9366 the file name.\n\
9367 ";
9368 static const char* _wrap_plvect_texinfo = "-*- texinfo -*-\n\
9369 Vector plot\n\
9370 \n\
9371 DESCRIPTION:\n\
9372 \n\
9373 Draws a plot of vector data contained in the matrices (\n\
9374 u[\n\
9375 nx][\n\
9376 ny],\n\
9377 v[\n\
9378 nx][\n\
9379 ny]) . The scaling factor for the vectors is given by scale. A\n\
9380 transformation routine pointed to by pltr with a pointer pltr_data for\n\
9381 additional data required by the transformation routine to map indices\n\
9382 within the matrices to the world coordinates. The style of the vector\n\
9383 arrow may be set using plsvect.\n\
9384 \n\
9385 Redacted form: plvect(u, v, scale, pltr, pltr_data) where (see above\n\
9386 discussion) the pltr, pltr_data callback arguments are sometimes\n\
9387 replaced by a tr vector with 6 elements, or xg and yg array arguments\n\
9388 with either one or two dimensions.\n\
9389 \n\
9390 This function is used in example 22.\n\
9391 \n\
9392 \n\
9393 \n\
9394 SYNOPSIS:\n\
9395 \n\
9396 plvect(u, v, nx, ny, scale, pltr, pltr_data)\n\
9397 \n\
9398 ARGUMENTS:\n\
9399 \n\
9400 u, v (PLFLT_MATRIX, input) : A pair of matrices containing the x\n\
9401 and y components of the vector data to be plotted.\n\
9402 \n\
9403 nx, ny (PLINT, input) : Dimensions of the matrices u and v.\n\
9404 \n\
9405 scale (PLFLT, input) : Parameter to control the scaling factor of\n\
9406 the vectors for plotting. If scale = 0 then the scaling factor is\n\
9407 automatically calculated for the data. If scale < 0 then the\n\
9408 scaling factor is automatically calculated for the data and then\n\
9409 multiplied by -\n\
9410 scale. If scale > 0 then the scaling factor is set to scale.\n\
9411 \n\
9412 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9413 defines the transformation between the zero-based indices of the\n\
9414 matrices u and v and world coordinates.For the C case,\n\
9415 transformation functions are provided in the PLplot library: pltr0\n\
9416 for the identity mapping, and pltr1 and pltr2 for arbitrary\n\
9417 mappings respectively defined by vectors and matrices. In\n\
9418 addition, C callback routines for the transformation can be\n\
9419 supplied by the user such as the mypltr function in\n\
9420 examples/c/x09c.c which provides a general linear transformation\n\
9421 between index coordinates and world coordinates.For languages\n\
9422 other than C you should consult the PLplot documentation for the\n\
9423 details concerning how PLTRANSFORM_callback arguments are\n\
9424 interfaced. However, in general, a particular pattern of\n\
9425 callback-associated arguments such as a tr vector with 6 elements;\n\
9426 xg and yg vectors; or xg and yg matrices are respectively\n\
9427 interfaced to a linear-transformation routine similar to the above\n\
9428 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9429 sophisticated bindings (see, e.g., the PLplot documentation)\n\
9430 support native language callbacks for handling index to\n\
9431 world-coordinate transformations. Examples of these various\n\
9432 approaches are given in examples/<language>x09*,\n\
9433 examples/<language>x16*, examples/<language>x20*,\n\
9434 examples/<language>x21*, and examples/<language>x22*, for all our\n\
9435 supported languages.\n\
9436 \n\
9437 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
9438 information to pltr0, pltr1, pltr2, or whatever callback routine\n\
9439 that is externally supplied.\n\
9440 ";
9441 static const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
9442 Set parameters that define current plot-space window\n\
9443 \n\
9444 DESCRIPTION:\n\
9445 \n\
9446 Set relative minima and maxima that define the current plot-space\n\
9447 window. If plsdiplt is not called the default values of xmin, ymin,\n\
9448 xmax, and ymax are 0., 0., 1., and 1.\n\
9449 \n\
9450 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
9451 \n\
9452 This function is used in example 31.\n\
9453 \n\
9454 \n\
9455 \n\
9456 SYNOPSIS:\n\
9457 \n\
9458 plsdiplt(xmin, ymin, xmax, ymax)\n\
9459 \n\
9460 ARGUMENTS:\n\
9461 \n\
9462 xmin (PLFLT, input) : Relative minimum in x.\n\
9463 \n\
9464 ymin (PLFLT, input) : Relative minimum in y.\n\
9465 \n\
9466 xmax (PLFLT, input) : Relative maximum in x.\n\
9467 \n\
9468 ymax (PLFLT, input) : Relative maximum in y.\n\
9469 ";
9470 static const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
9471 Select line style\n\
9472 \n\
9473 DESCRIPTION:\n\
9474 \n\
9475 This sets the line style according to one of eight predefined patterns\n\
9476 (also see plstyl).\n\
9477 \n\
9478 Redacted form: pllsty(lin)\n\
9479 \n\
9480 This function is used in examples 9, 12, 22, and 25.\n\
9481 \n\
9482 \n\
9483 \n\
9484 SYNOPSIS:\n\
9485 \n\
9486 pllsty(lin)\n\
9487 \n\
9488 ARGUMENTS:\n\
9489 \n\
9490 lin (PLINT, input) : Integer value between 1 and 8. Line style 1 is\n\
9491 a continuous line, line style 2 is a line with short dashes and\n\
9492 gaps, line style 3 is a line with long dashes and gaps, line style\n\
9493 4 has long dashes and short gaps and so on.\n\
9494 ";
9495 static const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
9496 Plot a glyph at the specified points\n\
9497 \n\
9498 DESCRIPTION:\n\
9499 \n\
9500 Plot a glyph at the specified points. (This function is largely\n\
9501 superseded by plstring which gives access to many[!] more glyphs.)\n\
9502 \n\
9503 Redacted form: plsym(x, y, code)\n\
9504 \n\
9505 This function is used in example 7.\n\
9506 \n\
9507 \n\
9508 \n\
9509 SYNOPSIS:\n\
9510 \n\
9511 plsym(n, x, y, code)\n\
9512 \n\
9513 ARGUMENTS:\n\
9514 \n\
9515 n (PLINT, input) : Number of points in the x and y vectors.\n\
9516 \n\
9517 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9518 the points.\n\
9519 \n\
9520 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9521 the points.\n\
9522 \n\
9523 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
9524 to be plotted at each of the n points.\n\
9525 ";
9526 static const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
9527 Set the device (keyword) name\n\
9528 \n\
9529 DESCRIPTION:\n\
9530 \n\
9531 Set the device (keyword) name.\n\
9532 \n\
9533 Redacted form: plsdev(devname)\n\
9534 \n\
9535 This function is used in examples 1, 14, and 20.\n\
9536 \n\
9537 \n\
9538 \n\
9539 SYNOPSIS:\n\
9540 \n\
9541 plsdev(devname)\n\
9542 \n\
9543 ARGUMENTS:\n\
9544 \n\
9545 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
9546 containing the device name keyword of the required output device.\n\
9547 If\n\
9548 devname is NULL or if the first character of the string is a ``?\'\',\n\
9549 the normal (prompted) start up is used.\n\
9550 ";
9551 static const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
9552 Set the background color by 8-bit RGB value\n\
9553 \n\
9554 DESCRIPTION:\n\
9555 \n\
9556 Set the background color (color 0 in cmap0) by 8-bit RGB value (see\n\
9557 the PLplot documentation).\n\
9558 \n\
9559 Redacted form: plscolbg(r, g, b)\n\
9560 \n\
9561 This function is used in examples 15 and 31.\n\
9562 \n\
9563 \n\
9564 \n\
9565 SYNOPSIS:\n\
9566 \n\
9567 plscolbg(r, g, b)\n\
9568 \n\
9569 ARGUMENTS:\n\
9570 \n\
9571 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9572 degree of red in the color.\n\
9573 \n\
9574 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9575 degree of green in the color.\n\
9576 \n\
9577 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
9578 degree of blue in the color.\n\
9579 ";
9580 static const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
9581 Set parameters incrementally (zoom mode) that define current plot-space window\n\
9582 \n\
9583 DESCRIPTION:\n\
9584 \n\
9585 Set relative minima and maxima incrementally (zoom mode) that define\n\
9586 the current plot-space window. This function has the same effect as\n\
9587 plsdiplt if that function has not been previously called. Otherwise,\n\
9588 this function implements zoom mode using the transformation min_used =\n\
9589 old_min + old_length*min and max_used = old_min + old_length*max for\n\
9590 each axis. For example, if min = 0.05 and max = 0.95 for each axis,\n\
9591 repeated calls to plsdiplz will zoom in by 10 per cent for each call.\n\
9592 \n\
9593 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
9594 \n\
9595 This function is used in example 31.\n\
9596 \n\
9597 \n\
9598 \n\
9599 SYNOPSIS:\n\
9600 \n\
9601 plsdiplz(xmin, ymin, xmax, ymax)\n\
9602 \n\
9603 ARGUMENTS:\n\
9604 \n\
9605 xmin (PLFLT, input) : Relative (incremental) minimum in x.\n\
9606 \n\
9607 ymin (PLFLT, input) : Relative (incremental) minimum in y.\n\
9608 \n\
9609 xmax (PLFLT, input) : Relative (incremental) maximum in x.\n\
9610 \n\
9611 ymax (PLFLT, input) : Relative (incremental) maximum in y.\n\
9612 ";
9613 static const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
9614 Advance to the next family file on the next new page\n\
9615 \n\
9616 DESCRIPTION:\n\
9617 \n\
9618 Advance to the next family file on the next new page.\n\
9619 \n\
9620 Redacted form: plfamadv()\n\
9621 \n\
9622 This function is not used in any examples.\n\
9623 \n\
9624 \n\
9625 \n\
9626 SYNOPSIS:\n\
9627 \n\
9628 plfamadv()\n\
9629 ";
9630 static const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
9631 Set number of colors in cmap0\n\
9632 \n\
9633 DESCRIPTION:\n\
9634 \n\
9635 Set number of colors in cmap0 (see the PLplot documentation). Allocate\n\
9636 (or reallocate) cmap0, and fill with default values for those colors\n\
9637 not previously allocated. The first 16 default colors are given in\n\
9638 the plcol0 documentation. For larger indices the default color is\n\
9639 red.\n\
9640 \n\
9641 The drivers are not guaranteed to support more than 16 colors.\n\
9642 \n\
9643 Redacted form: plscmap0n(ncol0)\n\
9644 \n\
9645 This function is used in examples 15, 16, and 24.\n\
9646 \n\
9647 \n\
9648 \n\
9649 SYNOPSIS:\n\
9650 \n\
9651 plscmap0n(ncol0)\n\
9652 \n\
9653 ARGUMENTS:\n\
9654 \n\
9655 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
9656 the cmap0 palette. If this number is zero or less, then the value\n\
9657 from the previous call to plscmap0n is used and if there is no\n\
9658 previous call, then a default value is used.\n\
9659 ";
9660 static const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
9661 Plot latitude and longitude lines\n\
9662 \n\
9663 DESCRIPTION:\n\
9664 \n\
9665 Displays latitude and longitude on the current plot. The lines are\n\
9666 plotted in the current color and line style.\n\
9667 \n\
9668 Redacted form: plmeridians(mapform, dlong, dlat, minlong, maxlong,\n\
9669 minlat, maxlat)\n\
9670 \n\
9671 This function is used in example 19.\n\
9672 \n\
9673 \n\
9674 \n\
9675 SYNOPSIS:\n\
9676 \n\
9677 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
9678 \n\
9679 ARGUMENTS:\n\
9680 \n\
9681 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
9682 transform the coordinate longitudes and latitudes to a plot\n\
9683 coordinate system. By using this transform, we can change from a\n\
9684 longitude, latitude coordinate to a polar stereographic project,\n\
9685 for example. Initially, x[0]..[n-1] are the longitudes and\n\
9686 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
9687 mapform(), x[] and y[] should be replaced by the corresponding\n\
9688 plot coordinates. If no transform is desired, mapform can be\n\
9689 replaced by NULL.\n\
9690 \n\
9691 dlong (PLFLT, input) : The interval in degrees at which the\n\
9692 longitude lines are to be plotted.\n\
9693 \n\
9694 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
9695 lines are to be plotted.\n\
9696 \n\
9697 minlong (PLFLT, input) : The value of the longitude on the left\n\
9698 side of the plot. The value of minlong must be less than the value\n\
9699 of maxlong, and the quantity maxlong-minlong must be less than or\n\
9700 equal to 360.\n\
9701 \n\
9702 maxlong (PLFLT, input) : The value of the longitude on the right\n\
9703 side of the plot.\n\
9704 \n\
9705 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
9706 background. One can always use -90.0 as the boundary outside the\n\
9707 plot window will be automatically eliminated. However, the\n\
9708 program will be faster if one can reduce the size of the\n\
9709 background plotted.\n\
9710 \n\
9711 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
9712 background. One can always use 90.0 as the boundary outside the\n\
9713 plot window will be automatically eliminated.\n\
9714 ";
9715 static const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
9716 Convert RGB color to HLS\n\
9717 \n\
9718 DESCRIPTION:\n\
9719 \n\
9720 Convert RGB color coordinates to HLS\n\
9721 \n\
9722 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9723 \n\
9724 \n\
9725 This function is used in example 2.\n\
9726 \n\
9727 \n\
9728 \n\
9729 SYNOPSIS:\n\
9730 \n\
9731 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
9732 \n\
9733 ARGUMENTS:\n\
9734 \n\
9735 r (PLFLT, input) : Red intensity (0.0-1.0) of the color.\n\
9736 \n\
9737 g (PLFLT, input) : Green intensity (0.0-1.0) of the color.\n\
9738 \n\
9739 b (PLFLT, input) : Blue intensity (0.0-1.0) of the color.\n\
9740 \n\
9741 p_h (PLFLT_NC_SCALAR, output) : Returned value of the hue in\n\
9742 degrees (0.0-360.0) on the color cylinder.\n\
9743 \n\
9744 p_l (PLFLT_NC_SCALAR, output) : Returned value of the lightness\n\
9745 expressed as a fraction (0.0-1.0) of the axis of the color\n\
9746 cylinder.\n\
9747 \n\
9748 p_s (PLFLT_NC_SCALAR, output) : Returned value of the saturation\n\
9749 expressed as a fraction (0.0-1.0) of the radius of the color\n\
9750 cylinder.\n\
9751 ";
9752 static const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
9753 Plot a glyph at the specified 3D points\n\
9754 \n\
9755 DESCRIPTION:\n\
9756 \n\
9757 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
9758 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
9759 this function similar to what is done for plline3. The glyph is\n\
9760 specified with a PLplot user string. Note that the user string is not\n\
9761 actually limited to one glyph so it is possible (but not normally\n\
9762 useful) to plot more than one glyph at the specified points with this\n\
9763 function. As with plmtex and plptex, the user string can contain FCI\n\
9764 escapes to determine the font, UTF-8 code to determine the glyph or\n\
9765 else PLplot escapes for Hershey or unicode text to determine the\n\
9766 glyph.\n\
9767 \n\
9768 Redacted form: plstring3(x, y, z, string)\n\
9769 \n\
9770 This function is used in example 18.\n\
9771 \n\
9772 \n\
9773 \n\
9774 SYNOPSIS:\n\
9775 \n\
9776 plstring3(n, x, y, z, string)\n\
9777 \n\
9778 ARGUMENTS:\n\
9779 \n\
9780 n (PLINT, input) : Number of points in the x, y, and z vectors.\n\
9781 \n\
9782 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
9783 the points.\n\
9784 \n\
9785 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
9786 the points.\n\
9787 \n\
9788 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
9789 the points.\n\
9790 \n\
9791 string (PLCHAR_VECTOR, input) : A UTF-8 character string containing\n\
9792 the glyph(s) to be plotted at each of the n points. points.\n\
9793 ";
9794 static const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
9795 Switch to text screen\n\
9796 \n\
9797 DESCRIPTION:\n\
9798 \n\
9799 Sets an interactive device to text mode, used in conjunction with\n\
9800 plgra to allow graphics and text to be interspersed. On a device\n\
9801 which supports separate text and graphics windows, this command causes\n\
9802 control to be switched to the text window. This can be useful for\n\
9803 printing diagnostic messages or getting user input, which would\n\
9804 otherwise interfere with the plots. The program must switch back to\n\
9805 the graphics window before issuing plot commands, as the text (or\n\
9806 console) device will probably become quite confused otherwise. If\n\
9807 already in text mode, this command is ignored. It is also ignored on\n\
9808 devices which only support a single window or use a different method\n\
9809 for shifting focus (see also plgra).\n\
9810 \n\
9811 Redacted form: pltext()\n\
9812 \n\
9813 This function is used in example 1.\n\
9814 \n\
9815 \n\
9816 \n\
9817 SYNOPSIS:\n\
9818 \n\
9819 pltext()\n\
9820 ";
9821 static const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
9822 Get parameters that define current plot-space window\n\
9823 \n\
9824 DESCRIPTION:\n\
9825 \n\
9826 Get relative minima and maxima that define current plot-space window.\n\
9827 If plsdiplt has not been called the default values pointed to by\n\
9828 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1.\n\
9829 \n\
9830 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9831 \n\
9832 This function is used in example 31.\n\
9833 \n\
9834 \n\
9835 \n\
9836 SYNOPSIS:\n\
9837 \n\
9838 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
9839 \n\
9840 ARGUMENTS:\n\
9841 \n\
9842 p_xmin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9843 minimum in x.\n\
9844 \n\
9845 p_ymin (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9846 minimum in y.\n\
9847 \n\
9848 p_xmax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9849 maximum in x.\n\
9850 \n\
9851 p_ymax (PLFLT_NC_SCALAR, output) : Returned value of the relative\n\
9852 maximum in y.\n\
9853 ";
9854 static const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
9855 Get the (current) run level\n\
9856 \n\
9857 DESCRIPTION:\n\
9858 \n\
9859 Get the (current) run level. Valid settings are: 0, uninitialized\n\
9860 1, initialized\n\
9861 2, viewport defined\n\
9862 3, world coordinates defined\n\
9863 \n\
9864 \n\
9865 Redacted form: plglevel(p_level)\n\
9866 \n\
9867 This function is used in example 31.\n\
9868 \n\
9869 \n\
9870 \n\
9871 SYNOPSIS:\n\
9872 \n\
9873 plglevel(p_level)\n\
9874 \n\
9875 ARGUMENTS:\n\
9876 \n\
9877 p_level (PLINT_NC_SCALAR, output) : Returned value of the run\n\
9878 level.\n\
9879 ";
9880 static const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
9881 Plot a histogram from binned data\n\
9882 \n\
9883 DESCRIPTION:\n\
9884 \n\
9885 Plots a histogram consisting of nbin bins. The value associated with\n\
9886 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
9887 placed in y[i]. For proper operation, the values in x[i] must form a\n\
9888 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
9889 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
9890 placed midway between the values in the x vector. Also see plhist for\n\
9891 drawing histograms from unbinned data.\n\
9892 \n\
9893 Redacted form: General: plbin(x, y, opt)\n\
9894 Python: plbin(nbin, x, y, opt)\n\
9895 \n\
9896 \n\
9897 This function is not used in any examples.\n\
9898 \n\
9899 \n\
9900 \n\
9901 SYNOPSIS:\n\
9902 \n\
9903 plbin(nbin, x, y, opt)\n\
9904 \n\
9905 ARGUMENTS:\n\
9906 \n\
9907 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
9908 and y vectors.)\n\
9909 \n\
9910 x (PLFLT_VECTOR, input) : A vector containing values associated\n\
9911 with bins. These must form a strictly increasing sequence.\n\
9912 \n\
9913 y (PLFLT_VECTOR, input) : A vector containing a number which is\n\
9914 proportional to the number of points in each bin. This is a PLFLT\n\
9915 (instead of PLINT) vector so as to allow histograms of\n\
9916 probabilities, etc.\n\
9917 \n\
9918 opt (PLINT, input) : Is a combination of several flags:\n\
9919 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
9920 outer bins are expanded to fill up the entire x-axis and bins of\n\
9921 zero height are simply drawn.\n\
9922 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
9923 between the x values. If the values in x are equally spaced,\n\
9924 the values are the center values of the bins.\n\
9925 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
9926 size as the ones inside.\n\
9927 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
9928 (there is a gap for such bins).\n\
9929 ";
9930 static const char* _wrap_plimagefr_texinfo = "-*- texinfo -*-\n\
9931 Plot a 2D matrix using cmap1\n\
9932 \n\
9933 DESCRIPTION:\n\
9934 \n\
9935 Plot a 2D matrix using cmap1.\n\
9936 \n\
9937 Redacted form: General: plimagefr(idata, xmin, xmax, ymin, ymax, zmin,\n\
9938 zmax, valuemin, valuemax, pltr, pltr_data)\n\
9939 \n\
9940 \n\
9941 This function is used in example 20.\n\
9942 \n\
9943 \n\
9944 \n\
9945 SYNOPSIS:\n\
9946 \n\
9947 plimagefr(idata, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr, pltr_data)\n\
9948 \n\
9949 ARGUMENTS:\n\
9950 \n\
9951 idata (PLFLT_MATRIX, input) : A matrix of values (intensities) to\n\
9952 plot. Should have dimensions of\n\
9953 nx by\n\
9954 ny.\n\
9955 \n\
9956 nx, ny (PLINT, input) : Dimensions of idata\n\
9957 \n\
9958 xmin, xmax, ymin, ymax (PLFLT, input) : See the discussion of\n\
9959 pltr below for how these arguments are used (only for the special case\n\
9960 when the callback function\n\
9961 pltr is not supplied).\n\
9962 \n\
9963 zmin, zmax (PLFLT, input) : Only data between zmin and zmax\n\
9964 (inclusive) will be plotted.\n\
9965 \n\
9966 valuemin, valuemax (PLFLT, input) : The minimum and maximum data\n\
9967 values to use for value to color mappings. A datum equal to or\n\
9968 less than valuemin will be plotted with color 0.0, while a datum\n\
9969 equal to or greater than valuemax will be plotted with color 1.0.\n\
9970 Data between valuemin and valuemax map linearly to colors in the\n\
9971 range (0.0-1.0).\n\
9972 \n\
9973 pltr (PLTRANSFORM_callback, input) : A callback function that\n\
9974 defines the transformation between the zero-based indices of the\n\
9975 matrix idata and world coordinates. If\n\
9976 pltr is not supplied (e.g., is set to NULL in the C case), then the x\n\
9977 indices of idata are mapped to the range\n\
9978 xmin through\n\
9979 xmax and the y indices of idata are mapped to the range\n\
9980 ymin through\n\
9981 ymax.For the C case, transformation functions are provided in the\n\
9982 PLplot library: pltr0 for the identity mapping, and pltr1 and\n\
9983 pltr2 for arbitrary mappings respectively defined by vectors and\n\
9984 matrices. In addition, C callback routines for the transformation\n\
9985 can be supplied by the user such as the mypltr function in\n\
9986 examples/c/x09c.c which provides a general linear transformation\n\
9987 between index coordinates and world coordinates.For languages\n\
9988 other than C you should consult the PLplot documentation for the\n\
9989 details concerning how PLTRANSFORM_callback arguments are\n\
9990 interfaced. However, in general, a particular pattern of\n\
9991 callback-associated arguments such as a tr vector with 6 elements;\n\
9992 xg and yg vectors; or xg and yg matrices are respectively\n\
9993 interfaced to a linear-transformation routine similar to the above\n\
9994 mypltr function; pltr1; and pltr2. Furthermore, some of our more\n\
9995 sophisticated bindings (see, e.g., the PLplot documentation)\n\
9996 support native language callbacks for handling index to\n\
9997 world-coordinate transformations. Examples of these various\n\
9998 approaches are given in examples/<language>x09*,\n\
9999 examples/<language>x16*, examples/<language>x20*,\n\
10000 examples/<language>x21*, and examples/<language>x22*, for all our\n\
10001 supported languages.\n\
10002 \n\
10003 pltr_data (PLPointer, input) : Extra parameter to help pass\n\
10004 information to pltr0, pltr1, pltr2, or whatever routine is\n\
10005 externally supplied.\n\
10006 ";
10007 static const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
10008 Get family, style and weight of the current font\n\
10009 \n\
10010 DESCRIPTION:\n\
10011 \n\
10012 Gets information about current font. See the PLplot documentation for\n\
10013 more information on font selection.\n\
10014 \n\
10015 Redacted form: plgfont(p_family, p_style, p_weight)\n\
10016 \n\
10017 This function is used in example 23.\n\
10018 \n\
10019 \n\
10020 \n\
10021 SYNOPSIS:\n\
10022 \n\
10023 plgfont(p_family, p_style, p_weight)\n\
10024 \n\
10025 ARGUMENTS:\n\
10026 \n\
10027 p_family (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10028 font family. The available values are given by the PL_FCI_*\n\
10029 constants in plplot.h. Current options are PL_FCI_SANS,\n\
10030 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
10031 p_family is NULL then the font family is not returned.\n\
10032 \n\
10033 p_style (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10034 font style. The available values are given by the PL_FCI_*\n\
10035 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
10036 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the font\n\
10037 style is not returned.\n\
10038 \n\
10039 p_weight (PLINT_NC_SCALAR, output) : Returned value of the current\n\
10040 font weight. The available values are given by the PL_FCI_*\n\
10041 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
10042 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
10043 returned.\n\
10044 ";
10045 static const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
10046 Get z axis parameters\n\
10047 \n\
10048 DESCRIPTION:\n\
10049 \n\
10050 Identical to plgxax, except that arguments are flags for z axis. See\n\
10051 the description of plgxax for more detail.\n\
10052 \n\
10053 Redacted form: plgzax(p_digmax, p_digits)\n\
10054 \n\
10055 This function is used in example 31.\n\
10056 \n\
10057 \n\
10058 \n\
10059 SYNOPSIS:\n\
10060 \n\
10061 plgzax(p_digmax, p_digits)\n\
10062 \n\
10063 ARGUMENTS:\n\
10064 \n\
10065 p_digmax (PLINT_NC_SCALAR, output) : Returned value of the maximum\n\
10066 number of digits for the z axis. If nonzero, the printed label\n\
10067 has been switched to a floating-point representation when the\n\
10068 number of digits exceeds this value.\n\
10069 \n\
10070 p_digits (PLINT_NC_SCALAR, output) : Returned value of the actual\n\
10071 number of digits for the numeric labels (z axis) from the last\n\
10072 plot.\n\
10073 ";
10074 static const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
10075 Write text inside the viewport of a 3D plot\n\
10076 \n\
10077 DESCRIPTION:\n\
10078 \n\
10079 Writes text at a specified position and inclination and with a\n\
10080 specified shear within the viewport. Text is clipped at the viewport\n\
10081 boundaries. The reference point of a string lies along a line passing\n\
10082 through the string at half the height of a capital letter. The\n\
10083 position of the reference point along this line is determined by just,\n\
10084 and the reference point is placed at world coordinates (\n\
10085 wx,\n\
10086 wy,\n\
10087 wz) within the viewport. The inclination and shear of the string is\n\
10088 specified in terms of differences of world coordinates making it easy\n\
10089 to write text parallel to a line in a graph.\n\
10090 \n\
10091 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
10092 \n\
10093 This function is used in example 28.\n\
10094 \n\
10095 \n\
10096 \n\
10097 SYNOPSIS:\n\
10098 \n\
10099 plptex3(wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text)\n\
10100 \n\
10101 ARGUMENTS:\n\
10102 \n\
10103 wx (PLFLT, input) : x world coordinate of reference point of\n\
10104 string.\n\
10105 \n\
10106 wy (PLFLT, input) : y world coordinate of reference point of\n\
10107 string.\n\
10108 \n\
10109 wz (PLFLT, input) : z world coordinate of reference point of\n\
10110 string.\n\
10111 \n\
10112 dx (PLFLT, input) : Together with dy and\n\
10113 dz , this specifies the inclination of the string. The baseline of\n\
10114 the string is parallel to a line joining (\n\
10115 x,\n\
10116 y,\n\
10117 z) to (\n\
10118 x+\n\
10119 dx,\n\
10120 y+\n\
10121 dy,\n\
10122 z+\n\
10123 dz) .\n\
10124 \n\
10125 dy (PLFLT, input) : Together with dx and\n\
10126 dz, this specifies the inclination of the string.\n\
10127 \n\
10128 dz (PLFLT, input) : Together with dx and\n\
10129 dy, this specifies the inclination of the string.\n\
10130 \n\
10131 sx (PLFLT, input) : Together with sy and\n\
10132 sz , this specifies the shear of the string. The string is sheared so\n\
10133 that the characters are vertically parallel to a line joining (\n\
10134 x,\n\
10135 y,\n\
10136 z) to (\n\
10137 x+\n\
10138 sx,\n\
10139 y+\n\
10140 sy,\n\
10141 z+\n\
10142 sz) . If sx =\n\
10143 sy =\n\
10144 sz = 0.) then the text is not sheared.\n\
10145 \n\
10146 sy (PLFLT, input) : Together with sx and\n\
10147 sz, this specifies shear of the string.\n\
10148 \n\
10149 sz (PLFLT, input) : Together with sx and\n\
10150 sy, this specifies shear of the string.\n\
10151 \n\
10152 just (PLFLT, input) : Specifies the position of the string relative\n\
10153 to its reference point. If just=0. , the reference point is at\n\
10154 the left and if just=1. , it is at the right of the string. Other\n\
10155 values of just give intermediate justifications.\n\
10156 \n\
10157 text (PLCHAR_VECTOR, input) : A UTF-8 character string to be\n\
10158 written out.\n\
10159 ";
10160 static const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
10161 Draw a box with axes, etc. with arbitrary origin\n\
10162 \n\
10163 DESCRIPTION:\n\
10164 \n\
10165 Draws a box around the currently defined viewport with arbitrary\n\
10166 world-coordinate origin specified by x0 and y0 and labels it with\n\
10167 world coordinate values appropriate to the window. Thus plaxes should\n\
10168 only be called after defining both viewport and window. The ascii\n\
10169 character strings xopt and yopt specify how the box should be drawn as\n\
10170 described below. If ticks and/or subticks are to be drawn for a\n\
10171 particular axis, the tick intervals and number of subintervals may be\n\
10172 specified explicitly, or they may be defaulted by setting the\n\
10173 appropriate arguments to zero.\n\
10174 \n\
10175 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
10176 ytick, nysub)\n\
10177 \n\
10178 \n\
10179 This function is not used in any examples.\n\
10180 \n\
10181 \n\
10182 \n\
10183 SYNOPSIS:\n\
10184 \n\
10185 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
10186 \n\
10187 ARGUMENTS:\n\
10188 \n\
10189 x0 (PLFLT, input) : World X coordinate of origin.\n\
10190 \n\
10191 y0 (PLFLT, input) : World Y coordinate of origin.\n\
10192 \n\
10193 xopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10194 options for the x axis. The string can include any combination of\n\
10195 the following letters (upper or lower case) in any order: a: Draws\n\
10196 axis, X-axis is horizontal line (y=0), and Y-axis is vertical line\n\
10197 (x=0).\n\
10198 b: Draws bottom (X) or left (Y) edge of frame.\n\
10199 c: Draws top (X) or right (Y) edge of frame.\n\
10200 d: Plot labels as date / time. Values are assumed to be\n\
10201 seconds since the epoch (as used by gmtime).\n\
10202 f: Always use fixed point numeric labels.\n\
10203 g: Draws a grid at the major tick interval.\n\
10204 h: Draws a grid at the minor tick interval.\n\
10205 i: Inverts tick marks, so they are drawn outwards, rather than\n\
10206 inwards.\n\
10207 l: Labels axis logarithmically. This only affects the labels,\n\
10208 not the data, and so it is necessary to compute the logarithms\n\
10209 of data points before passing them to any of the drawing\n\
10210 routines.\n\
10211 m: Writes numeric labels at major tick intervals in the\n\
10212 unconventional location (above box for X, right of box for Y).\n\
10213 n: Writes numeric labels at major tick intervals in the\n\
10214 conventional location (below box for X, left of box for Y).\n\
10215 o: Use custom labelling function to generate axis label text.\n\
10216 The custom labelling function can be defined with the\n\
10217 plslabelfunc command.\n\
10218 s: Enables subticks between major ticks, only valid if t is\n\
10219 also specified.\n\
10220 t: Draws major ticks.\n\
10221 u: Exactly like \"b\" except don\'t draw edge line.\n\
10222 w: Exactly like \"c\" except don\'t draw edge line.\n\
10223 x: Exactly like \"t\" (including the side effect of the\n\
10224 numerical labels for the major ticks) except exclude drawing\n\
10225 the major and minor tick marks.\n\
10226 \n\
10227 \n\
10228 xtick (PLFLT, input) : World coordinate interval between major\n\
10229 ticks on the x axis. If it is set to zero, PLplot automatically\n\
10230 generates a suitable tick interval.\n\
10231 \n\
10232 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
10233 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10234 generates a suitable minor tick interval.\n\
10235 \n\
10236 yopt (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10237 options for the y axis. The string can include any combination of\n\
10238 the letters defined above for xopt, and in addition may contain:\n\
10239 v: Write numeric labels for the y axis parallel to the base of the\n\
10240 graph, rather than parallel to the axis.\n\
10241 \n\
10242 \n\
10243 ytick (PLFLT, input) : World coordinate interval between major\n\
10244 ticks on the y axis. If it is set to zero, PLplot automatically\n\
10245 generates a suitable tick interval.\n\
10246 \n\
10247 nysub (PLINT, input) : Number of subintervals between major y axis\n\
10248 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
10249 generates a suitable minor tick interval.\n\
10250 ";
10251 static const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
10252 Returns the background color (cmap0[0]) by 8-bit RGB value\n\
10253 \n\
10254 DESCRIPTION:\n\
10255 \n\
10256 Returns the background color (cmap0[0]) by 8-bit RGB value.\n\
10257 \n\
10258 Redacted form: plgcolbg(r, g, b)\n\
10259 \n\
10260 This function is used in example 31.\n\
10261 \n\
10262 \n\
10263 \n\
10264 SYNOPSIS:\n\
10265 \n\
10266 plgcolbg(r, g, b)\n\
10267 \n\
10268 ARGUMENTS:\n\
10269 \n\
10270 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10271 in the range from 0 to 255.\n\
10272 \n\
10273 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10274 in the range from 0 to 255.\n\
10275 \n\
10276 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10277 in the range from 0 to 255.\n\
10278 ";
10279 static const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
10280 Plot a glyph at the specified 3D points\n\
10281 \n\
10282 DESCRIPTION:\n\
10283 \n\
10284 Plot a glyph at the specified 3D points. (This function is largely\n\
10285 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
10286 Set up the call to this function similar to what is done for plline3.\n\
10287 code=-1 means try to just draw a point. Right now it\'s just a move\n\
10288 and a draw at the same place. Not ideal, since a sufficiently\n\
10289 intelligent output device may optimize it away, or there may be faster\n\
10290 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
10291 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
10292 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
10293 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
10294 code <= 127 the corresponding printable ASCII character is plotted.\n\
10295 \n\
10296 Redacted form: plpoin3(x, y, z, code)\n\
10297 \n\
10298 This function is not used in any example.\n\
10299 \n\
10300 \n\
10301 \n\
10302 SYNOPSIS:\n\
10303 \n\
10304 plpoin3(n, x, y, z, code)\n\
10305 \n\
10306 ARGUMENTS:\n\
10307 \n\
10308 n (PLINT, input) : Number of points in the x and y vectors.\n\
10309 \n\
10310 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10311 points.\n\
10312 \n\
10313 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10314 points.\n\
10315 \n\
10316 z (PLFLT_VECTOR, input) : A vector containing the z coordinates of\n\
10317 points.\n\
10318 \n\
10319 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
10320 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
10321 each of the n points.\n\
10322 ";
10323 static const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
10324 Draw a polygon in 3 space\n\
10325 \n\
10326 DESCRIPTION:\n\
10327 \n\
10328 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
10329 like plline3, but differs from that function in that plpoly3 attempts\n\
10330 to determine if the polygon is viewable depending on the order of the\n\
10331 points within the vector and the value of ifcc. If the back of\n\
10332 polygon is facing the viewer, then it isn\'t drawn. If this isn\'t what\n\
10333 you want, then use plline3 instead.\n\
10334 \n\
10335 The points are assumed to be in a plane, and the directionality of the\n\
10336 plane is determined from the first three points. Additional points do\n\
10337 not have to lie on the plane defined by the first three, but if they\n\
10338 do not, then the determination of visibility obviously can\'t be 100%\n\
10339 accurate... So if you\'re 3 space polygons are too far from planar,\n\
10340 consider breaking them into smaller polygons. 3 points define a plane\n\
10341 :-).\n\
10342 \n\
10343 Bugs: If one of the first two segments is of zero length, or if they\n\
10344 are co-linear, the calculation of visibility has a 50/50 chance of\n\
10345 being correct. Avoid such situations :-). See x18c.c for an example\n\
10346 of this problem. (Search for 20.1).\n\
10347 \n\
10348 Redacted form: plpoly3(x, y, z, code)\n\
10349 \n\
10350 This function is used in example 18.\n\
10351 \n\
10352 \n\
10353 \n\
10354 SYNOPSIS:\n\
10355 \n\
10356 plpoly3(n, x, y, z, draw, ifcc)\n\
10357 \n\
10358 ARGUMENTS:\n\
10359 \n\
10360 n (PLINT, input) : Number of points defining line.\n\
10361 \n\
10362 x (PLFLT_VECTOR, input) : A vector containing\n\
10363 n x coordinates of points.\n\
10364 \n\
10365 y (PLFLT_VECTOR, input) : A vector containing\n\
10366 n y coordinates of points.\n\
10367 \n\
10368 z (PLFLT_VECTOR, input) : A vector containing\n\
10369 n z coordinates of points.\n\
10370 \n\
10371 draw (PLBOOL_VECTOR, input) : A vector containing\n\
10372 n-1 Boolean values which control drawing the segments of the polygon.\n\
10373 If draw[i] is true, then the polygon segment from index [i] to\n\
10374 [i+1] is drawn, otherwise, not.\n\
10375 \n\
10376 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
10377 polygon is determined by assuming the points are laid out in a\n\
10378 counter-clockwise order. Otherwise, the directionality of the\n\
10379 polygon is determined by assuming the points are laid out in a\n\
10380 clockwise order.\n\
10381 ";
10382 static const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
10383 Set the background color by 8-bit RGB value and PLFLT alpha transparency value.\n\
10384 \n\
10385 DESCRIPTION:\n\
10386 \n\
10387 Set the background color (color 0 in cmap0) by 8-bit RGB value and\n\
10388 PLFLT alpha transparency value (see the PLplot documentation).\n\
10389 \n\
10390 This function is used in example 31.\n\
10391 \n\
10392 \n\
10393 \n\
10394 SYNOPSIS:\n\
10395 \n\
10396 plscolbga(r, g, b, alpha)\n\
10397 \n\
10398 ARGUMENTS:\n\
10399 \n\
10400 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10401 degree of red in the color.\n\
10402 \n\
10403 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10404 degree of green in the color.\n\
10405 \n\
10406 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
10407 degree of blue in the color.\n\
10408 \n\
10409 alpha (PLFLT, input) : Value of the alpha transparency in the range\n\
10410 (0.0-1.0).\n\
10411 ";
10412 static const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
10413 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT alpha transparency value\n\
10414 \n\
10415 DESCRIPTION:\n\
10416 \n\
10417 Returns the background color (cmap0[0]) by 8-bit RGB value and PLFLT\n\
10418 alpha transparency value.\n\
10419 \n\
10420 This function is used in example 31.\n\
10421 \n\
10422 \n\
10423 \n\
10424 SYNOPSIS:\n\
10425 \n\
10426 plgcolbga(r, g, b, alpha)\n\
10427 \n\
10428 ARGUMENTS:\n\
10429 \n\
10430 r (PLINT_NC_SCALAR, output) : Returned value of the red intensity\n\
10431 in the range from 0 to 255.\n\
10432 \n\
10433 g (PLINT_NC_SCALAR, output) : Returned value of the green intensity\n\
10434 in the range from 0 to 255.\n\
10435 \n\
10436 b (PLINT_NC_SCALAR, output) : Returned value of the blue intensity\n\
10437 in the range from 0 to 255.\n\
10438 \n\
10439 alpha (PLFLT_NC_SCALAR, output) : Returned value of the alpha\n\
10440 transparency in the range (0.0-1.0).\n\
10441 ";
10442 static const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
10443 Draw error bars in x direction\n\
10444 \n\
10445 DESCRIPTION:\n\
10446 \n\
10447 Draws a set of n error bars in x direction, the i\'th error bar\n\
10448 extending from xmin[i] to xmax[i] at y coordinate y[i]. The terminals\n\
10449 of the error bars are of length equal to the minor tick length\n\
10450 (settable using plsmin).\n\
10451 \n\
10452 Redacted form: General: plerrx(xmin, ymax, y)\n\
10453 \n\
10454 \n\
10455 This function is used in example 29.\n\
10456 \n\
10457 \n\
10458 \n\
10459 SYNOPSIS:\n\
10460 \n\
10461 plerrx(n, xmin, xmax, y)\n\
10462 \n\
10463 ARGUMENTS:\n\
10464 \n\
10465 n (PLINT, input) : Number of error bars to draw.\n\
10466 \n\
10467 xmin (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10468 of the left-hand endpoints of the error bars.\n\
10469 \n\
10470 xmax (PLFLT_VECTOR, input) : A vector containing the x coordinates\n\
10471 of the right-hand endpoints of the error bars.\n\
10472 \n\
10473 y (PLFLT_VECTOR, input) : A vector containing the y coordinates of\n\
10474 the error bars.\n\
10475 ";
10476 static const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
10477 Eject current page\n\
10478 \n\
10479 DESCRIPTION:\n\
10480 \n\
10481 Clears the graphics screen of an interactive device, or ejects a page\n\
10482 on a plotter. See plbop for more information.\n\
10483 \n\
10484 Redacted form: pleop()\n\
10485 \n\
10486 This function is used in example 2,14.\n\
10487 \n\
10488 \n\
10489 \n\
10490 SYNOPSIS:\n\
10491 \n\
10492 pleop()\n\
10493 ";
10494 static const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
10495 Convert HLS color to RGB\n\
10496 \n\
10497 DESCRIPTION:\n\
10498 \n\
10499 Convert HLS color coordinates to RGB.\n\
10500 \n\
10501 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10502 \n\
10503 \n\
10504 This function is used in example 2.\n\
10505 \n\
10506 \n\
10507 \n\
10508 SYNOPSIS:\n\
10509 \n\
10510 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
10511 \n\
10512 ARGUMENTS:\n\
10513 \n\
10514 h (PLFLT, input) : Hue in degrees (0.0-360.0) on the color\n\
10515 cylinder.\n\
10516 \n\
10517 l (PLFLT, input) : Lightness expressed as a fraction (0.0-1.0) of\n\
10518 the axis of the color cylinder.\n\
10519 \n\
10520 s (PLFLT, input) : Saturation expressed as a fraction (0.0-1.0) of\n\
10521 the radius of the color cylinder.\n\
10522 \n\
10523 p_r (PLFLT_NC_SCALAR, output) : Returned value of the red intensity\n\
10524 (0.0-1.0) of the color.\n\
10525 \n\
10526 p_g (PLFLT_NC_SCALAR, output) : Returned value of the green\n\
10527 intensity (0.0-1.0) of the color.\n\
10528 \n\
10529 p_b (PLFLT_NC_SCALAR, output) : Returned value of the blue\n\
10530 intensity (0.0-1.0) of the color.\n\
10531 ";
10532 static const char* _wrap_plmapfill_texinfo = "-*- texinfo -*-\n\
10533 Plot all or a subset of Shapefile data, filling the polygons\n\
10534 \n\
10535 DESCRIPTION:\n\
10536 \n\
10537 As per plmapline, however the items are filled in the same way as\n\
10538 plfill.\n\
10539 \n\
10540 Redacted form: plmapfill(mapform, name, minx, maxx, miny, maxy,\n\
10541 plotentries)\n\
10542 \n\
10543 This function is used in example 19.\n\
10544 \n\
10545 \n\
10546 \n\
10547 SYNOPSIS:\n\
10548 \n\
10549 plmapfill(mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries)\n\
10550 \n\
10551 ARGUMENTS:\n\
10552 \n\
10553 mapform (PLMAPFORM_callback, input) : A user supplied function to\n\
10554 transform the coordinates given in the shapefile into a plot\n\
10555 coordinate system. By using this transform, we can change from a\n\
10556 longitude, latitude coordinate to a polar stereographic project,\n\
10557 for example. Initially, x[0]..[n-1] are the longitudes and\n\
10558 y[0]..y[n-1] are the corresponding latitudes. After the call to\n\
10559 mapform(), x[] and y[] should be replaced by the corresponding\n\
10560 plot coordinates. If no transform is desired, mapform can be\n\
10561 replaced by NULL.\n\
10562 \n\
10563 name (PLCHAR_VECTOR, input) : An ascii character string specifying\n\
10564 the file name of a set of Shapefile files without the file\n\
10565 extension.\n\
10566 \n\
10567 minx (PLFLT, input) : The minimum x value to be plotted. This must\n\
10568 be in the same units as used by the Shapefile. You could use a\n\
10569 very large negative number to plot everything, but you can improve\n\
10570 performance by limiting the area drawn. The units must match those\n\
10571 of the Shapefile projection, which may be for example longitude or\n\
10572 distance. The value of minx must be less than the value of maxx.\n\
10573 \n\
10574 maxx (PLFLT, input) : The maximum x value to be plotted. You could\n\
10575 use a very large number to plot everything, but you can improve\n\
10576 performance by limiting the area drawn.\n\
10577 \n\
10578 miny (PLFLT, input) : The minimum y value to be plotted. This must\n\
10579 be in the same units as used by the Shapefile. You could use a\n\
10580 very large negative number to plot everything, but you can improve\n\
10581 performance by limiting the area drawn. The units must match those\n\
10582 of the Shapefile projection, which may be for example latitude or\n\
10583 distance. The value of miny must be less than the value of maxy.\n\
10584 \n\
10585 maxy (PLFLT, input) : The maximum y value to be plotted. You could\n\
10586 use a very large number to plot everything, but you can improve\n\
10587 performance by limiting the area drawn.\n\
10588 \n\
10589 plotentries (PLINT_VECTOR, input) : A vector containing the\n\
10590 zero-based indices of the Shapefile elements which will be drawn.\n\
10591 Setting\n\
10592 plotentries to NULL will plot all elements of the Shapefile.\n\
10593 \n\
10594 nplotentries (PLINT, input) : The number of items in\n\
10595 plotentries. Ignored if\n\
10596 plotentries is NULL.\n\
10597 ";
10598 static const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
10599 Draw error bars in the y direction\n\
10600 \n\
10601 DESCRIPTION:\n\
10602 \n\
10603 Draws a set of n error bars in the y direction, the i\'th error bar\n\
10604 extending from ymin[i] to ymax[i] at x coordinate x[i]. The terminals\n\
10605 of the error bars are of length equal to the minor tick length\n\
10606 (settable using plsmin).\n\
10607 \n\
10608 Redacted form: General: plerry(x, ymin, ymax)\n\
10609 \n\
10610 \n\
10611 This function is used in example 29.\n\
10612 \n\
10613 \n\
10614 \n\
10615 SYNOPSIS:\n\
10616 \n\
10617 plerry(n, x, ymin, ymax)\n\
10618 \n\
10619 ARGUMENTS:\n\
10620 \n\
10621 n (PLINT, input) : Number of error bars to draw.\n\
10622 \n\
10623 x (PLFLT_VECTOR, input) : A vector containing the x coordinates of\n\
10624 the error bars.\n\
10625 \n\
10626 ymin (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10627 of the lower endpoints of the error bars.\n\
10628 \n\
10629 ymax (PLFLT_VECTOR, input) : A vector containing the y coordinates\n\
10630 of the upper endpoints of the error bars.\n\
10631 ";
10632 static const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
10633 Set FCI (font characterization integer)\n\
10634 \n\
10635 DESCRIPTION:\n\
10636 \n\
10637 Sets font characteristics to be used at the start of the next string\n\
10638 using the FCI approach. See the PLplot documentation for more\n\
10639 information. Note, plsfont (which calls plsfci internally) provides a\n\
10640 more user-friendly API for setting the font characterisitics.\n\
10641 \n\
10642 Redacted form: General: plsfci(fci)\n\
10643 \n\
10644 \n\
10645 This function is used in example 23.\n\
10646 \n\
10647 \n\
10648 \n\
10649 SYNOPSIS:\n\
10650 \n\
10651 plsfci(fci)\n\
10652 \n\
10653 ARGUMENTS:\n\
10654 \n\
10655 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
10656 of FCI.\n\
10657 ";
10658 static const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
10659 Select area fill pattern\n\
10660 \n\
10661 DESCRIPTION:\n\
10662 \n\
10663 If\n\
10664 patt is zero or less use either a hardware solid fill if the drivers\n\
10665 have that capability (virtually all do) or fall back to a software\n\
10666 emulation of a solid fill using the eighth area line fill pattern. If\n\
10667 0 <\n\
10668 patt <= 8, then select one of eight predefined area line fill patterns\n\
10669 to use (see plpat if you desire other patterns).\n\
10670 \n\
10671 Redacted form: plpsty(patt)\n\
10672 \n\
10673 This function is used in examples 12, 13, 15, 16, and 25.\n\
10674 \n\
10675 \n\
10676 \n\
10677 SYNOPSIS:\n\
10678 \n\
10679 plpsty(patt)\n\
10680 \n\
10681 ARGUMENTS:\n\
10682 \n\
10683 patt (PLINT, input) : The desired pattern index. If\n\
10684 patt is zero or less, then a solid fill is (normally, see qualifiers\n\
10685 above) used. For\n\
10686 patt in the range from 1 to 8 and assuming the driver has not supplied\n\
10687 line fill capability itself (most deliberately do not so that line\n\
10688 fill patterns look identical for those drivers), the patterns\n\
10689 consist of (1) horizontal lines, (2) vertical lines, (3) lines at\n\
10690 45 degrees, (4) lines at -45 degrees, (5) lines at 30 degrees, (6)\n\
10691 lines at -30 degrees, (7) both vertical and horizontal lines, and\n\
10692 (8) lines at both 45 degrees and -45 degrees.\n\
10693 ";
10694 static const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
10695 Set symbol size\n\
10696 \n\
10697 DESCRIPTION:\n\
10698 \n\
10699 This sets up the size of all subsequent symbols drawn by plpoin and\n\
10700 plsym. The actual height of a symbol is the product of the default\n\
10701 symbol size and a scaling factor as for the character height.\n\
10702 \n\
10703 Redacted form: plssym(def, scale)\n\
10704 \n\
10705 This function is used in example 29.\n\
10706 \n\
10707 \n\
10708 \n\
10709 SYNOPSIS:\n\
10710 \n\
10711 plssym(def, scale)\n\
10712 \n\
10713 ARGUMENTS:\n\
10714 \n\
10715 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
10716 should be set to zero if the default height is to remain\n\
10717 unchanged.\n\
10718 \n\
10719 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
10720 actual symbol height.\n\
10721 ";
10722 static const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
10723 Initialization\n\
10724 \n\
10725 DESCRIPTION:\n\
10726 \n\
10727 Alternative to plstar for initializing the plotting package. The\n\
10728 device name keyword for the desired output device must be supplied as\n\
10729 an argument. These keywords are the same as those printed out by\n\
10730 plstar. If the requested device is not available, or if the input\n\
10731 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
10732 is used. This routine also divides the output device page into nx by\n\
10733 ny subpages, each of which may be used independently. The subroutine\n\
10734 pladv is used to advance from one subpage to the next.\n\
10735 \n\
10736 Redacted form: General: plstart(devname, nx, ny)\n\
10737 \n\
10738 \n\
10739 This function is not used in any examples.\n\
10740 \n\
10741 \n\
10742 \n\
10743 SYNOPSIS:\n\
10744 \n\
10745 plstart(devname, nx, ny)\n\
10746 \n\
10747 ARGUMENTS:\n\
10748 \n\
10749 devname (PLCHAR_VECTOR, input) : An ascii character string\n\
10750 containing the device name keyword of the required output device.\n\
10751 If\n\
10752 devname is NULL or if the first character of the string is a ``?\'\',\n\
10753 the normal (prompted) start up is used.\n\
10754 \n\
10755 nx (PLINT, input) : Number of subpages to divide output page in the\n\
10756 x direction.\n\
10757 \n\
10758 ny (PLINT, input) : Number of subpages to divide output page in the\n\
10759 y direction.\n\
10760 ";
10761
10762 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
10763 PLINT arg1 ;
10764 PLINT *arg2 = (PLINT *) 0 ;
10765 char **arg3 = (char **) 0 ;
10766 Matrix temp1 ;
10767 octave_value_list _out;
10768 octave_value_list *_outp=&_out;
10769 octave_value _outv;
10770
10771 if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
10772 SWIG_fail;
10773 }
10774 {
10775 if ( _n_dims( args(0) ) > 1 )
10776 {
10777 error( "argument must be a scalar or vector" ); SWIG_fail;
10778 }
10779 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
10780 arg2 = new PLINT[Alen];
10781 temp1 = args(0).matrix_value();
10782 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
10783 }
10784 {
10785 charMatrix temp_matrix;
10786 Cell temp_cell;
10787 char *tmp_cstring;
10788 std::string str;
10789 size_t max_length = 0, non_blank_length;
10790 int i, ifcell;
10791 if ( _n_dims( args(1) ) > 2 )
10792 {
10793 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
10794 }
10795 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10796 if ( !args(1).isempty() )
10797 #else
10798 if ( !args(1).is_empty() )
10799 #endif
10800 {
10801 if ( _dim( args(1), 0 ) != Alen )
10802 {
10803 error( "first dimension must be same length as previous vector" ); SWIG_fail;
10804 }
10805 arg3 = new char*[Alen];
10806 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
10807 ifcell = args(1).iscell();
10808 #else
10809 ifcell = args(1).is_cell();
10810 #endif
10811 if ( ifcell )
10812 {
10813 temp_cell = args(1).cell_value();
10814 }
10815 else
10816 {
10817 temp_matrix = args(1).char_matrix_value();
10818 // Allow one extra space for null termination.
10819 max_length = _dim( args(1), 1 ) + 1;
10820 }
10821
10822 for ( i = 0; i < Alen; i++ )
10823 {
10824 // Must copy string to "permanent" location because the string
10825 // location corresponding to tmp_cstring gets
10826 // overwritten for each iteration of loop.
10827 if ( ifcell )
10828 {
10829 if ( temp_cell.elem( i ).is_string() )
10830 {
10831 str = temp_cell.elem( i ).string_value();
10832 // leave room for null termination.
10833 max_length = str.size() + 1;
10834 tmp_cstring = (char *) str.c_str();
10835 }
10836 else
10837 {
10838 // Use null string if user attempts to pass a cell array
10839 // with a non-string element (likely an empty element
10840 // since that should be allowed by the PLplot interface
10841 // if that element is going to be unused).
10842 // leave room for null termination.
10843 max_length = 1;
10844 tmp_cstring = (char *) "";
10845 }
10846 }
10847 else
10848 {
10849 str = temp_matrix.row_as_string( i );
10850 tmp_cstring = (char *) str.c_str();
10851 }
10852 arg3[i] = new char[max_length];
10853 strncpy( arg3[i], tmp_cstring, max_length - 1 );
10854 arg3[i][max_length - 1] = '\0';
10855 // All the trailing blank crapola should not be needed for
10856 // string cell arrays.
10857 if ( !ifcell )
10858 {
10859 // remove trailing-blank padding that is used by the
10860 // charMatrix class to insure all strings in a given
10861 // charMatrix instance have the same length.
10862 // This transformation also removes legitimate trailing
10863 // blanks but there is nothing we can do about that
10864 // for the charMatrix class.
10865
10866 // Look for trailing nulls first (just in case, although that
10867 // shouldn't happen if charMatrix implemented as documented)
10868 // before looking for trailing blanks.
10869 non_blank_length = max_length - 2;
10870 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
10871 {
10872 non_blank_length--;
10873 }
10874 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
10875 {
10876 non_blank_length--;
10877 }
10878 arg3[i][non_blank_length + 1] = '\0';
10879 }
10880 }
10881 }
10882 else
10883 {
10884 arg3 = NULL;
10885 }
10886 }
10887 testppchar(arg1,(int const *)arg2,(char const **)arg3);
10888 _outv = octave_value();
10889 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10890 {
10891 delete [] arg2;
10892 }
10893 {
10894 int i;
10895 if ( arg3 != NULL )
10896 {
10897 for ( i = 0; i < Alen; i++ )
10898 {
10899 delete[] arg3[i];
10900 }
10901 delete[] arg3;
10902 }
10903 }
10904 return _out;
10905 fail:
10906 {
10907 delete [] arg2;
10908 }
10909 {
10910 int i;
10911 if ( arg3 != NULL )
10912 {
10913 for ( i = 0; i < Alen; i++ )
10914 {
10915 delete[] arg3[i];
10916 }
10917 delete[] arg3;
10918 }
10919 }
10920 return octave_value_list();
10921 }
10922
10923
10924 SWIG_DEFUN( plGetCursor, _wrap_plGetCursor, _wrap_plGetCursor_texinfo ) {
10925 int *arg1 = (int *) 0 ;
10926 int *arg2 = (int *) 0 ;
10927 int *arg3 = (int *) 0 ;
10928 char *arg4 = (char *) 0 ;
10929 int *arg5 = (int *) 0 ;
10930 int *arg6 = (int *) 0 ;
10931 PLFLT *arg7 = (PLFLT *) 0 ;
10932 PLFLT *arg8 = (PLFLT *) 0 ;
10933 PLFLT *arg9 = (PLFLT *) 0 ;
10934 PLFLT *arg10 = (PLFLT *) 0 ;
10935 int *arg11 = (int *) 0 ;
10936 int temp1 ;
10937 int res1 = SWIG_TMPOBJ ;
10938 int temp2 ;
10939 int res2 = SWIG_TMPOBJ ;
10940 int temp3 ;
10941 int res3 = SWIG_TMPOBJ ;
10942 char local_string4[80] ;
10943 int temp5 ;
10944 int res5 = SWIG_TMPOBJ ;
10945 int temp6 ;
10946 int res6 = SWIG_TMPOBJ ;
10947 PLFLT temp7 ;
10948 int res7 = SWIG_TMPOBJ ;
10949 PLFLT temp8 ;
10950 int res8 = SWIG_TMPOBJ ;
10951 PLFLT temp9 ;
10952 int res9 = SWIG_TMPOBJ ;
10953 PLFLT temp10 ;
10954 int res10 = SWIG_TMPOBJ ;
10955 int temp11 ;
10956 int res11 = SWIG_TMPOBJ ;
10957 size_t local_string_length4 ;
10958 charMatrix local_charMatrix4 ;
10959 octave_value_list retval4 ;
10960 octave_value_list _out;
10961 octave_value_list *_outp=&_out;
10962 octave_value _outv;
10963 int result;
10964
10965 arg1 = &temp1;
10966 arg2 = &temp2;
10967 arg3 = &temp3;
10968 {
10969 arg4 = local_string4;
10970 }
10971 arg5 = &temp5;
10972 arg6 = &temp6;
10973 arg7 = &temp7;
10974 arg8 = &temp8;
10975 arg9 = &temp9;
10976 arg10 = &temp10;
10977 arg11 = &temp11;
10978 if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
10979 SWIG_fail;
10980 }
10981 result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
10982 _outv = SWIG_From_int(static_cast< int >(result));
10983 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10984 if (SWIG_IsTmpObj(res1)) {
10985 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
10986 } else {
10987 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10988 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
10989 }
10990 if (SWIG_IsTmpObj(res2)) {
10991 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
10992 } else {
10993 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
10994 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
10995 }
10996 if (SWIG_IsTmpObj(res3)) {
10997 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
10998 } else {
10999 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11000 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
11001 }
11002 {
11003 local_string_length4 = strlen( local_string4 );
11004 local_charMatrix4 = charMatrix( 1, local_string_length4 );
11005 local_charMatrix4.insert( local_string4, 0, 0 );
11006 retval4( 0 ) = octave_value( local_charMatrix4 );
11007 _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
11008 }
11009 if (SWIG_IsTmpObj(res5)) {
11010 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
11011 } else {
11012 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11013 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
11014 }
11015 if (SWIG_IsTmpObj(res6)) {
11016 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
11017 } else {
11018 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11019 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
11020 }
11021 if (SWIG_IsTmpObj(res7)) {
11022 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
11023 } else {
11024 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11025 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
11026 }
11027 if (SWIG_IsTmpObj(res8)) {
11028 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
11029 } else {
11030 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11031 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
11032 }
11033 if (SWIG_IsTmpObj(res9)) {
11034 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
11035 } else {
11036 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11037 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
11038 }
11039 if (SWIG_IsTmpObj(res10)) {
11040 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
11041 } else {
11042 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11043 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
11044 }
11045 if (SWIG_IsTmpObj(res11)) {
11046 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
11047 } else {
11048 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11049 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
11050 }
11051 return _out;
11052 fail:
11053 return octave_value_list();
11054 }
11055
11056
11057 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
11058 PLFLT *arg1 = (PLFLT *) 0 ;
11059 PLFLT *arg2 = (PLFLT *) 0 ;
11060 PLFLT arg3 ;
11061 PLFLT arg4 ;
11062 PLFLT temp1 ;
11063 int res1 = SWIG_TMPOBJ ;
11064 PLFLT temp2 ;
11065 int res2 = SWIG_TMPOBJ ;
11066 double val3 ;
11067 int ecode3 = 0 ;
11068 double val4 ;
11069 int ecode4 = 0 ;
11070 octave_value_list _out;
11071 octave_value_list *_outp=&_out;
11072 octave_value _outv;
11073 int result;
11074
11075 arg1 = &temp1;
11076 arg2 = &temp2;
11077 if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
11078 SWIG_fail;
11079 }
11080 ecode3 = SWIG_AsVal_double(args(0), &val3);
11081 if (!SWIG_IsOK(ecode3)) {
11082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
11083 }
11084 arg3 = static_cast< PLFLT >(val3);
11085 ecode4 = SWIG_AsVal_double(args(1), &val4);
11086 if (!SWIG_IsOK(ecode4)) {
11087 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
11088 }
11089 arg4 = static_cast< PLFLT >(val4);
11090 result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
11091 _outv = SWIG_From_int(static_cast< int >(result));
11092 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11093 if (SWIG_IsTmpObj(res1)) {
11094 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
11095 } else {
11096 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11097 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
11098 }
11099 if (SWIG_IsTmpObj(res2)) {
11100 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
11101 } else {
11102 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11103 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
11104 }
11105 return _out;
11106 fail:
11107 return octave_value_list();
11108 }
11109
11110
11111 SWIG_DEFUN( plstripc, _wrap_plstripc, _wrap_plstripc_texinfo ) {
11112 PLINT *arg1 = (PLINT *) 0 ;
11113 char *arg2 = (char *) 0 ;
11114 char *arg3 = (char *) 0 ;
11115 PLFLT arg4 ;
11116 PLFLT arg5 ;
11117 PLFLT arg6 ;
11118 PLFLT arg7 ;
11119 PLFLT arg8 ;
11120 PLFLT arg9 ;
11121 PLFLT arg10 ;
11122 PLBOOL arg11 ;
11123 PLBOOL arg12 ;
11124 PLINT arg13 ;
11125 PLINT arg14 ;
11126 PLINT *arg15 = (PLINT *) 0 ;
11127 PLINT *arg16 = (PLINT *) 0 ;
11128 char *arg17 = (char *) 0 ;
11129 char *arg18 = (char *) 0 ;
11130 char *arg19 = (char *) 0 ;
11131 char *arg20 = (char *) 0 ;
11132 char *arg21 = (char *) 0 ;
11133 char *arg22 = (char *) 0 ;
11134 char *arg23 = (char *) 0 ;
11135 PLINT temp1 ;
11136 int res1 = SWIG_TMPOBJ ;
11137 int res2 ;
11138 char *buf2 = 0 ;
11139 int alloc2 = 0 ;
11140 int res3 ;
11141 char *buf3 = 0 ;
11142 int alloc3 = 0 ;
11143 double val4 ;
11144 int ecode4 = 0 ;
11145 double val5 ;
11146 int ecode5 = 0 ;
11147 double val6 ;
11148 int ecode6 = 0 ;
11149 double val7 ;
11150 int ecode7 = 0 ;
11151 double val8 ;
11152 int ecode8 = 0 ;
11153 double val9 ;
11154 int ecode9 = 0 ;
11155 double val10 ;
11156 int ecode10 = 0 ;
11157 int val11 ;
11158 int ecode11 = 0 ;
11159 int val12 ;
11160 int ecode12 = 0 ;
11161 int val13 ;
11162 int ecode13 = 0 ;
11163 int val14 ;
11164 int ecode14 = 0 ;
11165 Matrix temp15 ;
11166 Matrix temp16 ;
11167 int res17 ;
11168 char *buf17 = 0 ;
11169 int alloc17 = 0 ;
11170 int res18 ;
11171 char *buf18 = 0 ;
11172 int alloc18 = 0 ;
11173 int res19 ;
11174 char *buf19 = 0 ;
11175 int alloc19 = 0 ;
11176 int res20 ;
11177 char *buf20 = 0 ;
11178 int alloc20 = 0 ;
11179 int res21 ;
11180 char *buf21 = 0 ;
11181 int alloc21 = 0 ;
11182 int res22 ;
11183 char *buf22 = 0 ;
11184 int alloc22 = 0 ;
11185 int res23 ;
11186 char *buf23 = 0 ;
11187 int alloc23 = 0 ;
11188 octave_value_list _out;
11189 octave_value_list *_outp=&_out;
11190 octave_value _outv;
11191
11192 arg1 = &temp1;
11193 if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
11194 SWIG_fail;
11195 }
11196 res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
11197 if (!SWIG_IsOK(res2)) {
11198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
11199 }
11200 arg2 = reinterpret_cast< char * >(buf2);
11201 res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
11202 if (!SWIG_IsOK(res3)) {
11203 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
11204 }
11205 arg3 = reinterpret_cast< char * >(buf3);
11206 ecode4 = SWIG_AsVal_double(args(2), &val4);
11207 if (!SWIG_IsOK(ecode4)) {
11208 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
11209 }
11210 arg4 = static_cast< PLFLT >(val4);
11211 ecode5 = SWIG_AsVal_double(args(3), &val5);
11212 if (!SWIG_IsOK(ecode5)) {
11213 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
11214 }
11215 arg5 = static_cast< PLFLT >(val5);
11216 ecode6 = SWIG_AsVal_double(args(4), &val6);
11217 if (!SWIG_IsOK(ecode6)) {
11218 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
11219 }
11220 arg6 = static_cast< PLFLT >(val6);
11221 ecode7 = SWIG_AsVal_double(args(5), &val7);
11222 if (!SWIG_IsOK(ecode7)) {
11223 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
11224 }
11225 arg7 = static_cast< PLFLT >(val7);
11226 ecode8 = SWIG_AsVal_double(args(6), &val8);
11227 if (!SWIG_IsOK(ecode8)) {
11228 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
11229 }
11230 arg8 = static_cast< PLFLT >(val8);
11231 ecode9 = SWIG_AsVal_double(args(7), &val9);
11232 if (!SWIG_IsOK(ecode9)) {
11233 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
11234 }
11235 arg9 = static_cast< PLFLT >(val9);
11236 ecode10 = SWIG_AsVal_double(args(8), &val10);
11237 if (!SWIG_IsOK(ecode10)) {
11238 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
11239 }
11240 arg10 = static_cast< PLFLT >(val10);
11241 ecode11 = SWIG_AsVal_int(args(9), &val11);
11242 if (!SWIG_IsOK(ecode11)) {
11243 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
11244 }
11245 arg11 = static_cast< PLBOOL >(val11);
11246 ecode12 = SWIG_AsVal_int(args(10), &val12);
11247 if (!SWIG_IsOK(ecode12)) {
11248 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
11249 }
11250 arg12 = static_cast< PLBOOL >(val12);
11251 ecode13 = SWIG_AsVal_int(args(11), &val13);
11252 if (!SWIG_IsOK(ecode13)) {
11253 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
11254 }
11255 arg13 = static_cast< PLINT >(val13);
11256 ecode14 = SWIG_AsVal_int(args(12), &val14);
11257 if (!SWIG_IsOK(ecode14)) {
11258 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
11259 }
11260 arg14 = static_cast< PLINT >(val14);
11261 {
11262 if ( _n_dims( args(13) ) > 1 )
11263 {
11264 error( "argument must be a scalar or vector" ); SWIG_fail;
11265 }
11266 Alen = (PLINT) ( _dim( args(13), 0 ) );
11267 temp15 = args(13).matrix_value();
11268 arg15 = new PLINT[Alen];
11269 _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
11270 }
11271 {
11272 if ( _n_dims( args(14) ) > 1 )
11273 {
11274 error( "argument must be a scalar or vector" ); SWIG_fail;
11275 }
11276 if ( _dim( args(14), 0 ) != Alen )
11277 {
11278 error( "argument vectors must be same length" ); SWIG_fail;
11279 }
11280 temp16 = args(14).matrix_value();
11281 arg16 = new PLINT[Alen];
11282 _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
11283 }
11284 res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
11285 if (!SWIG_IsOK(res17)) {
11286 SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
11287 }
11288 arg17 = reinterpret_cast< char * >(buf17);
11289 res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
11290 if (!SWIG_IsOK(res18)) {
11291 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
11292 }
11293 arg18 = reinterpret_cast< char * >(buf18);
11294 res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
11295 if (!SWIG_IsOK(res19)) {
11296 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
11297 }
11298 arg19 = reinterpret_cast< char * >(buf19);
11299 res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
11300 if (!SWIG_IsOK(res20)) {
11301 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
11302 }
11303 arg20 = reinterpret_cast< char * >(buf20);
11304 res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
11305 if (!SWIG_IsOK(res21)) {
11306 SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
11307 }
11308 arg21 = reinterpret_cast< char * >(buf21);
11309 res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
11310 if (!SWIG_IsOK(res22)) {
11311 SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
11312 }
11313 arg22 = reinterpret_cast< char * >(buf22);
11314 res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
11315 if (!SWIG_IsOK(res23)) {
11316 SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
11317 }
11318 arg23 = reinterpret_cast< char * >(buf23);
11319 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);
11320 _outv = octave_value();
11321 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11322 if (SWIG_IsTmpObj(res1)) {
11323 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
11324 } else {
11325 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
11326 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
11327 }
11328 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11329 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11330 {
11331 delete [] arg15;
11332 }
11333 {
11334 delete [] arg16;
11335 }
11336 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11337 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11338 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11339 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11340 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11341 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11342 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11343 return _out;
11344 fail:
11345 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
11346 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
11347 {
11348 delete [] arg15;
11349 }
11350 {
11351 delete [] arg16;
11352 }
11353 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
11354 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
11355 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
11356 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
11357 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
11358 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
11359 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
11360 return octave_value_list();
11361 }
11362
11363
11364 SWIG_DEFUN( plcont, _wrap_plcont, _wrap_plcont_texinfo ) {
11365 PLFLT *arg1 = (PLFLT *) 0 ;
11366 PLINT arg2 ;
11367 PLINT arg3 ;
11368 PLINT arg4 ;
11369 PLINT arg5 ;
11370 PLINT arg6 ;
11371 PLINT arg7 ;
11372 PLFLT *arg8 = (PLFLT *) 0 ;
11373 PLINT arg9 ;
11374 PLFLT *arg10 = (PLFLT *) 0 ;
11375 Matrix temp1 ;
11376 int val4 ;
11377 int ecode4 = 0 ;
11378 int val5 ;
11379 int ecode5 = 0 ;
11380 int val6 ;
11381 int ecode6 = 0 ;
11382 int val7 ;
11383 int ecode7 = 0 ;
11384 Matrix temp8 ;
11385 Matrix temp10 ;
11386 octave_value_list _out;
11387 octave_value_list *_outp=&_out;
11388 octave_value _outv;
11389
11390 if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
11391 SWIG_fail;
11392 }
11393 {
11394 if ( _n_dims( args(0) ) > 2 )
11395 {
11396 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11397 }
11398 temp1 = args(0).matrix_value();
11399 arg1 = &temp1( 0, 0 );
11400 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11401 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11402 }
11403 ecode4 = SWIG_AsVal_int(args(1), &val4);
11404 if (!SWIG_IsOK(ecode4)) {
11405 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
11406 }
11407 arg4 = static_cast< PLINT >(val4);
11408 ecode5 = SWIG_AsVal_int(args(2), &val5);
11409 if (!SWIG_IsOK(ecode5)) {
11410 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
11411 }
11412 arg5 = static_cast< PLINT >(val5);
11413 ecode6 = SWIG_AsVal_int(args(3), &val6);
11414 if (!SWIG_IsOK(ecode6)) {
11415 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
11416 }
11417 arg6 = static_cast< PLINT >(val6);
11418 ecode7 = SWIG_AsVal_int(args(4), &val7);
11419 if (!SWIG_IsOK(ecode7)) {
11420 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
11421 }
11422 arg7 = static_cast< PLINT >(val7);
11423 {
11424 if ( _n_dims( args(5) ) > 1 )
11425 {
11426 error( "argument must be a scalar or vector" ); SWIG_fail;
11427 }
11428 temp8 = args(5).matrix_value();
11429 arg8 = &temp8( 0, 0 );
11430 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11431 }
11432 {
11433 if ( _n_dims( args(6) ) > 1 )
11434 {
11435 error( "argument must be a scalar or vector" ); SWIG_fail;
11436 }
11437 if ( _dim( args(6), 0 ) != 6 )
11438 {
11439 error( "argument vectors must have length of 6" ); SWIG_fail;
11440 }
11441 temp10 = args(6).matrix_value();
11442 arg10 = &temp10( 0, 0 );
11443 }
11444 my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
11445 _outv = octave_value();
11446 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11447 {
11448
11449 }
11450 {
11451
11452 }
11453 {
11454
11455 }
11456 return _out;
11457 fail:
11458 {
11459
11460 }
11461 {
11462
11463 }
11464 {
11465
11466 }
11467 return octave_value_list();
11468 }
11469
11470
11471 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
11472 PLFLT *arg1 = (PLFLT *) 0 ;
11473 PLINT arg2 ;
11474 PLINT arg3 ;
11475 PLINT arg4 ;
11476 PLINT arg5 ;
11477 PLINT arg6 ;
11478 PLINT arg7 ;
11479 PLFLT *arg8 = (PLFLT *) 0 ;
11480 PLINT arg9 ;
11481 Matrix temp1 ;
11482 int val4 ;
11483 int ecode4 = 0 ;
11484 int val5 ;
11485 int ecode5 = 0 ;
11486 int val6 ;
11487 int ecode6 = 0 ;
11488 int val7 ;
11489 int ecode7 = 0 ;
11490 Matrix temp8 ;
11491 octave_value_list _out;
11492 octave_value_list *_outp=&_out;
11493 octave_value _outv;
11494
11495 if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
11496 SWIG_fail;
11497 }
11498 {
11499 if ( _n_dims( args(0) ) > 2 )
11500 {
11501 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11502 }
11503 temp1 = args(0).matrix_value();
11504 arg1 = &temp1( 0, 0 );
11505 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11506 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11507 }
11508 ecode4 = SWIG_AsVal_int(args(1), &val4);
11509 if (!SWIG_IsOK(ecode4)) {
11510 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
11511 }
11512 arg4 = static_cast< PLINT >(val4);
11513 ecode5 = SWIG_AsVal_int(args(2), &val5);
11514 if (!SWIG_IsOK(ecode5)) {
11515 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
11516 }
11517 arg5 = static_cast< PLINT >(val5);
11518 ecode6 = SWIG_AsVal_int(args(3), &val6);
11519 if (!SWIG_IsOK(ecode6)) {
11520 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
11521 }
11522 arg6 = static_cast< PLINT >(val6);
11523 ecode7 = SWIG_AsVal_int(args(4), &val7);
11524 if (!SWIG_IsOK(ecode7)) {
11525 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
11526 }
11527 arg7 = static_cast< PLINT >(val7);
11528 {
11529 if ( _n_dims( args(5) ) > 1 )
11530 {
11531 error( "argument must be a scalar or vector" ); SWIG_fail;
11532 }
11533 temp8 = args(5).matrix_value();
11534 arg8 = &temp8( 0, 0 );
11535 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11536 }
11537 my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
11538 _outv = octave_value();
11539 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11540 {
11541
11542 }
11543 {
11544
11545 }
11546 return _out;
11547 fail:
11548 {
11549
11550 }
11551 {
11552
11553 }
11554 return octave_value_list();
11555 }
11556
11557
11558 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
11559 PLFLT *arg1 = (PLFLT *) 0 ;
11560 PLINT arg2 ;
11561 PLINT arg3 ;
11562 PLINT arg4 ;
11563 PLINT arg5 ;
11564 PLINT arg6 ;
11565 PLINT arg7 ;
11566 PLFLT *arg8 = (PLFLT *) 0 ;
11567 PLINT arg9 ;
11568 PLFLT *arg10 = (PLFLT *) 0 ;
11569 PLFLT *arg11 = (PLFLT *) 0 ;
11570 Matrix temp1 ;
11571 int val4 ;
11572 int ecode4 = 0 ;
11573 int val5 ;
11574 int ecode5 = 0 ;
11575 int val6 ;
11576 int ecode6 = 0 ;
11577 int val7 ;
11578 int ecode7 = 0 ;
11579 Matrix temp8 ;
11580 Matrix temp10 ;
11581 Matrix temp11 ;
11582 octave_value_list _out;
11583 octave_value_list *_outp=&_out;
11584 octave_value _outv;
11585
11586 if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
11587 SWIG_fail;
11588 }
11589 {
11590 if ( _n_dims( args(0) ) > 2 )
11591 {
11592 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11593 }
11594 temp1 = args(0).matrix_value();
11595 arg1 = &temp1( 0, 0 );
11596 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11597 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11598 }
11599 ecode4 = SWIG_AsVal_int(args(1), &val4);
11600 if (!SWIG_IsOK(ecode4)) {
11601 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
11602 }
11603 arg4 = static_cast< PLINT >(val4);
11604 ecode5 = SWIG_AsVal_int(args(2), &val5);
11605 if (!SWIG_IsOK(ecode5)) {
11606 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
11607 }
11608 arg5 = static_cast< PLINT >(val5);
11609 ecode6 = SWIG_AsVal_int(args(3), &val6);
11610 if (!SWIG_IsOK(ecode6)) {
11611 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
11612 }
11613 arg6 = static_cast< PLINT >(val6);
11614 ecode7 = SWIG_AsVal_int(args(4), &val7);
11615 if (!SWIG_IsOK(ecode7)) {
11616 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
11617 }
11618 arg7 = static_cast< PLINT >(val7);
11619 {
11620 if ( _n_dims( args(5) ) > 1 )
11621 {
11622 error( "argument must be a scalar or vector" ); SWIG_fail;
11623 }
11624 temp8 = args(5).matrix_value();
11625 arg8 = &temp8( 0, 0 );
11626 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11627 }
11628 {
11629 if ( _n_dims( args(6) ) > 1 )
11630 {
11631 error( "argument must be a scalar or vector" ); SWIG_fail;
11632 }
11633 if ( _dim( args(6), 0 ) != Xlen )
11634 {
11635 error( "argument vectors must be same length" ); SWIG_fail;
11636 }
11637 temp10 = args(6).matrix_value();
11638 arg10 = &temp10( 0, 0 );
11639 }
11640 {
11641 if ( _n_dims( args(7) ) > 1 )
11642 {
11643 error( "argument must be a scalar or vector" ); SWIG_fail;
11644 }
11645 if ( _dim( args(7), 0 ) != Ylen )
11646 {
11647 error( "argument vectors must be same length" ); SWIG_fail;
11648 }
11649 temp11 = args(7).matrix_value();
11650 arg11 = &temp11( 0, 0 );
11651 }
11652 my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11653 _outv = octave_value();
11654 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11655 {
11656
11657 }
11658 {
11659
11660 }
11661 {
11662
11663 }
11664 {
11665
11666 }
11667 return _out;
11668 fail:
11669 {
11670
11671 }
11672 {
11673
11674 }
11675 {
11676
11677 }
11678 {
11679
11680 }
11681 return octave_value_list();
11682 }
11683
11684
11685 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
11686 PLFLT *arg1 = (PLFLT *) 0 ;
11687 PLINT arg2 ;
11688 PLINT arg3 ;
11689 PLINT arg4 ;
11690 PLINT arg5 ;
11691 PLINT arg6 ;
11692 PLINT arg7 ;
11693 PLFLT *arg8 = (PLFLT *) 0 ;
11694 PLINT arg9 ;
11695 PLFLT *arg10 = (PLFLT *) 0 ;
11696 PLFLT *arg11 = (PLFLT *) 0 ;
11697 Matrix temp1 ;
11698 int val4 ;
11699 int ecode4 = 0 ;
11700 int val5 ;
11701 int ecode5 = 0 ;
11702 int val6 ;
11703 int ecode6 = 0 ;
11704 int val7 ;
11705 int ecode7 = 0 ;
11706 Matrix temp8 ;
11707 Matrix temp10 ;
11708 Matrix temp11 ;
11709 octave_value_list _out;
11710 octave_value_list *_outp=&_out;
11711 octave_value _outv;
11712
11713 if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
11714 SWIG_fail;
11715 }
11716 {
11717 if ( _n_dims( args(0) ) > 2 )
11718 {
11719 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11720 }
11721 temp1 = args(0).matrix_value();
11722 arg1 = &temp1( 0, 0 );
11723 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11724 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11725 }
11726 ecode4 = SWIG_AsVal_int(args(1), &val4);
11727 if (!SWIG_IsOK(ecode4)) {
11728 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
11729 }
11730 arg4 = static_cast< PLINT >(val4);
11731 ecode5 = SWIG_AsVal_int(args(2), &val5);
11732 if (!SWIG_IsOK(ecode5)) {
11733 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
11734 }
11735 arg5 = static_cast< PLINT >(val5);
11736 ecode6 = SWIG_AsVal_int(args(3), &val6);
11737 if (!SWIG_IsOK(ecode6)) {
11738 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
11739 }
11740 arg6 = static_cast< PLINT >(val6);
11741 ecode7 = SWIG_AsVal_int(args(4), &val7);
11742 if (!SWIG_IsOK(ecode7)) {
11743 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
11744 }
11745 arg7 = static_cast< PLINT >(val7);
11746 {
11747 if ( _n_dims( args(5) ) > 1 )
11748 {
11749 error( "argument must be a scalar or vector" ); SWIG_fail;
11750 }
11751 temp8 = args(5).matrix_value();
11752 arg8 = &temp8( 0, 0 );
11753 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11754 }
11755 {
11756 if ( _n_dims( args(6) ) > 2 )
11757 {
11758 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11759 }
11760 if ( _dim( args(6), 0 ) != Xlen )
11761 {
11762 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11763 }
11764 if ( _dim( args(6), 1 ) != Ylen )
11765 {
11766 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11767 }
11768 temp10 = args(6).matrix_value();
11769 arg10 = &temp10( 0, 0 );
11770 }
11771 {
11772 if ( _n_dims( args(7) ) > 2 )
11773 {
11774 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11775 }
11776 if ( _dim( args(7), 0 ) != Xlen )
11777 {
11778 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11779 }
11780 if ( _dim( args(7), 1 ) != Ylen )
11781 {
11782 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11783 }
11784 temp11 = args(7).matrix_value();
11785 arg11 = &temp11( 0, 0 );
11786 }
11787 my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11788 _outv = octave_value();
11789 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11790 {
11791
11792 }
11793 {
11794
11795 }
11796 {
11797
11798 }
11799 {
11800
11801 }
11802 return _out;
11803 fail:
11804 {
11805
11806 }
11807 {
11808
11809 }
11810 {
11811
11812 }
11813 {
11814
11815 }
11816 return octave_value_list();
11817 }
11818
11819
11820 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
11821 PLFLT *arg1 = (PLFLT *) 0 ;
11822 PLINT arg2 ;
11823 PLINT arg3 ;
11824 PLINT arg4 ;
11825 PLINT arg5 ;
11826 PLINT arg6 ;
11827 PLINT arg7 ;
11828 PLFLT *arg8 = (PLFLT *) 0 ;
11829 PLINT arg9 ;
11830 PLFLT *arg10 = (PLFLT *) 0 ;
11831 PLFLT *arg11 = (PLFLT *) 0 ;
11832 Matrix temp1 ;
11833 int val4 ;
11834 int ecode4 = 0 ;
11835 int val5 ;
11836 int ecode5 = 0 ;
11837 int val6 ;
11838 int ecode6 = 0 ;
11839 int val7 ;
11840 int ecode7 = 0 ;
11841 Matrix temp8 ;
11842 Matrix temp10 ;
11843 Matrix temp11 ;
11844 octave_value_list _out;
11845 octave_value_list *_outp=&_out;
11846 octave_value _outv;
11847
11848 if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
11849 SWIG_fail;
11850 }
11851 {
11852 if ( _n_dims( args(0) ) > 2 )
11853 {
11854 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11855 }
11856 temp1 = args(0).matrix_value();
11857 arg1 = &temp1( 0, 0 );
11858 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11859 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11860 }
11861 ecode4 = SWIG_AsVal_int(args(1), &val4);
11862 if (!SWIG_IsOK(ecode4)) {
11863 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
11864 }
11865 arg4 = static_cast< PLINT >(val4);
11866 ecode5 = SWIG_AsVal_int(args(2), &val5);
11867 if (!SWIG_IsOK(ecode5)) {
11868 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
11869 }
11870 arg5 = static_cast< PLINT >(val5);
11871 ecode6 = SWIG_AsVal_int(args(3), &val6);
11872 if (!SWIG_IsOK(ecode6)) {
11873 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
11874 }
11875 arg6 = static_cast< PLINT >(val6);
11876 ecode7 = SWIG_AsVal_int(args(4), &val7);
11877 if (!SWIG_IsOK(ecode7)) {
11878 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
11879 }
11880 arg7 = static_cast< PLINT >(val7);
11881 {
11882 if ( _n_dims( args(5) ) > 1 )
11883 {
11884 error( "argument must be a scalar or vector" ); SWIG_fail;
11885 }
11886 temp8 = args(5).matrix_value();
11887 arg8 = &temp8( 0, 0 );
11888 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
11889 }
11890 {
11891 if ( _n_dims( args(6) ) > 2 )
11892 {
11893 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11894 }
11895 if ( _dim( args(6), 0 ) != Xlen )
11896 {
11897 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11898 }
11899 if ( _dim( args(6), 1 ) != Ylen )
11900 {
11901 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11902 }
11903 temp10 = args(6).matrix_value();
11904 arg10 = &temp10( 0, 0 );
11905 }
11906 {
11907 if ( _n_dims( args(7) ) > 2 )
11908 {
11909 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11910 }
11911 if ( _dim( args(7), 0 ) != Xlen )
11912 {
11913 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11914 }
11915 if ( _dim( args(7), 1 ) != Ylen )
11916 {
11917 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11918 }
11919 temp11 = args(7).matrix_value();
11920 arg11 = &temp11( 0, 0 );
11921 }
11922 my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
11923 _outv = octave_value();
11924 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11925 {
11926
11927 }
11928 {
11929
11930 }
11931 {
11932
11933 }
11934 {
11935
11936 }
11937 return _out;
11938 fail:
11939 {
11940
11941 }
11942 {
11943
11944 }
11945 {
11946
11947 }
11948 {
11949
11950 }
11951 return octave_value_list();
11952 }
11953
11954
11955 SWIG_DEFUN( plgriddata, _wrap_plgriddata, _wrap_plgriddata_texinfo ) {
11956 PLFLT *arg1 = (PLFLT *) 0 ;
11957 PLFLT *arg2 = (PLFLT *) 0 ;
11958 PLFLT *arg3 = (PLFLT *) 0 ;
11959 PLINT arg4 ;
11960 PLFLT *arg5 = (PLFLT *) 0 ;
11961 PLINT arg6 ;
11962 PLFLT *arg7 = (PLFLT *) 0 ;
11963 PLINT arg8 ;
11964 PLFLT *arg9 = (PLFLT *) 0 ;
11965 PLINT arg10 ;
11966 PLFLT arg11 ;
11967 Matrix temp1 ;
11968 Matrix temp2 ;
11969 Matrix temp3 ;
11970 Matrix temp5 ;
11971 Matrix temp7 ;
11972 octave_value_list retval7 ;
11973 int val10 ;
11974 int ecode10 = 0 ;
11975 double val11 ;
11976 int ecode11 = 0 ;
11977 octave_value_list _out;
11978 octave_value_list *_outp=&_out;
11979 octave_value _outv;
11980
11981 if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
11982 SWIG_fail;
11983 }
11984 {
11985 if ( _n_dims( args(0) ) > 1 )
11986 {
11987 error( "argument must be a scalar or vector" ); SWIG_fail;
11988 }
11989 Alen = (PLINT) ( _dim( args(0), 0 ) );
11990 temp1 = args(0).matrix_value();
11991 arg1 = &temp1( 0, 0 );
11992 }
11993 {
11994 if ( _n_dims( args(1) ) > 1 )
11995 {
11996 error( "argument must be a scalar or vector" ); SWIG_fail;
11997 }
11998 if ( _dim( args(1), 0 ) != Alen )
11999 {
12000 error( "argument vectors must be same length" ); SWIG_fail;
12001 }
12002 temp2 = args(1).matrix_value();
12003 arg2 = &temp2( 0, 0 );
12004 }
12005 {
12006 if ( _n_dims( args(2) ) > 1 )
12007 {
12008 error( "argument must be a scalar or vector" ); SWIG_fail;
12009 }
12010 if ( _dim( args(2), 0 ) != Alen )
12011 {
12012 error( "argument vectors must be same length" ); SWIG_fail;
12013 }
12014 temp3 = args(2).matrix_value();
12015 arg3 = &temp3( 0, 0 );
12016 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12017 }
12018 {
12019 if ( _n_dims( args(3) ) > 1 )
12020 {
12021 error( "argument must be a scalar or vector" ); SWIG_fail;
12022 }
12023 temp5 = args(3).matrix_value();
12024 arg5 = &temp5( 0, 0 );
12025 arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
12026 }
12027 {
12028 if ( _n_dims( args(4) ) > 1 )
12029 {
12030 error( "argument must be a scalar or vector" ); SWIG_fail;
12031 }
12032 temp7 = args(4).matrix_value();
12033 arg7 = &temp7( 0, 0 );
12034 arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
12035 retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
12036 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
12037 }
12038 ecode10 = SWIG_AsVal_int(args(5), &val10);
12039 if (!SWIG_IsOK(ecode10)) {
12040 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
12041 }
12042 arg10 = static_cast< PLINT >(val10);
12043 ecode11 = SWIG_AsVal_double(args(6), &val11);
12044 if (!SWIG_IsOK(ecode11)) {
12045 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
12046 }
12047 arg11 = static_cast< PLFLT >(val11);
12048 my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
12049 _outv = octave_value();
12050 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12051 {
12052 _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
12053 }
12054 {
12055
12056 }
12057 {
12058
12059 }
12060 {
12061
12062 }
12063 {
12064
12065 }
12066 {
12067
12068 }
12069 return _out;
12070 fail:
12071 {
12072
12073 }
12074 {
12075
12076 }
12077 {
12078
12079 }
12080 {
12081
12082 }
12083 {
12084
12085 }
12086 return octave_value_list();
12087 }
12088
12089
12090 SWIG_DEFUN( plmesh, _wrap_plmesh, _wrap_plmesh_texinfo ) {
12091 PLFLT *arg1 = (PLFLT *) 0 ;
12092 PLFLT *arg2 = (PLFLT *) 0 ;
12093 PLFLT *arg3 = (PLFLT *) 0 ;
12094 PLINT arg4 ;
12095 PLINT arg5 ;
12096 PLINT arg6 ;
12097 Matrix temp1 ;
12098 Matrix temp2 ;
12099 Matrix temp3 ;
12100 int val6 ;
12101 int ecode6 = 0 ;
12102 octave_value_list _out;
12103 octave_value_list *_outp=&_out;
12104 octave_value _outv;
12105
12106 if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
12107 SWIG_fail;
12108 }
12109 {
12110 if ( _n_dims( args(0) ) > 1 )
12111 {
12112 error( "argument must be a scalar or vector" ); SWIG_fail;
12113 }
12114 temp1 = args(0).matrix_value();
12115 arg1 = &temp1( 0, 0 );
12116 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12117 }
12118 {
12119 if ( _n_dims( args(1) ) > 1 )
12120 {
12121 error( "argument must be a scalar or vector" ); SWIG_fail;
12122 }
12123 temp2 = args(1).matrix_value();
12124 arg2 = &temp2( 0, 0 );
12125 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12126 }
12127 {
12128 if ( _n_dims( args(2) ) > 2 )
12129 {
12130 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12131 }
12132 if ( _dim( args(2), 0 ) != Xlen )
12133 {
12134 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12135 }
12136 if ( _dim( args(2), 1 ) != Ylen )
12137 {
12138 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12139 }
12140 temp3 = args(2).matrix_value();
12141 arg3 = &temp3( 0, 0 );
12142 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12143 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12144 }
12145 ecode6 = SWIG_AsVal_int(args(3), &val6);
12146 if (!SWIG_IsOK(ecode6)) {
12147 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
12148 }
12149 arg6 = static_cast< PLINT >(val6);
12150 my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
12151 _outv = octave_value();
12152 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12153 {
12154
12155 }
12156 {
12157
12158 }
12159 {
12160
12161 }
12162 return _out;
12163 fail:
12164 {
12165
12166 }
12167 {
12168
12169 }
12170 {
12171
12172 }
12173 return octave_value_list();
12174 }
12175
12176
12177 SWIG_DEFUN( plmeshc, _wrap_plmeshc, _wrap_plmeshc_texinfo ) {
12178 PLFLT *arg1 = (PLFLT *) 0 ;
12179 PLFLT *arg2 = (PLFLT *) 0 ;
12180 PLFLT *arg3 = (PLFLT *) 0 ;
12181 PLINT arg4 ;
12182 PLINT arg5 ;
12183 PLINT arg6 ;
12184 PLFLT *arg7 = (PLFLT *) 0 ;
12185 PLINT arg8 ;
12186 Matrix temp1 ;
12187 Matrix temp2 ;
12188 Matrix temp3 ;
12189 int val6 ;
12190 int ecode6 = 0 ;
12191 Matrix temp7 ;
12192 octave_value_list _out;
12193 octave_value_list *_outp=&_out;
12194 octave_value _outv;
12195
12196 if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
12197 SWIG_fail;
12198 }
12199 {
12200 if ( _n_dims( args(0) ) > 1 )
12201 {
12202 error( "argument must be a scalar or vector" ); SWIG_fail;
12203 }
12204 temp1 = args(0).matrix_value();
12205 arg1 = &temp1( 0, 0 );
12206 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12207 }
12208 {
12209 if ( _n_dims( args(1) ) > 1 )
12210 {
12211 error( "argument must be a scalar or vector" ); SWIG_fail;
12212 }
12213 temp2 = args(1).matrix_value();
12214 arg2 = &temp2( 0, 0 );
12215 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12216 }
12217 {
12218 if ( _n_dims( args(2) ) > 2 )
12219 {
12220 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12221 }
12222 if ( _dim( args(2), 0 ) != Xlen )
12223 {
12224 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12225 }
12226 if ( _dim( args(2), 1 ) != Ylen )
12227 {
12228 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12229 }
12230 temp3 = args(2).matrix_value();
12231 arg3 = &temp3( 0, 0 );
12232 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12233 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12234 }
12235 ecode6 = SWIG_AsVal_int(args(3), &val6);
12236 if (!SWIG_IsOK(ecode6)) {
12237 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
12238 }
12239 arg6 = static_cast< PLINT >(val6);
12240 {
12241 if ( _n_dims( args(4) ) > 1 )
12242 {
12243 error( "argument must be a scalar or vector" ); SWIG_fail;
12244 }
12245 temp7 = args(4).matrix_value();
12246 arg7 = &temp7( 0, 0 );
12247 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12248 }
12249 my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12250 _outv = octave_value();
12251 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12252 {
12253
12254 }
12255 {
12256
12257 }
12258 {
12259
12260 }
12261 {
12262
12263 }
12264 return _out;
12265 fail:
12266 {
12267
12268 }
12269 {
12270
12271 }
12272 {
12273
12274 }
12275 {
12276
12277 }
12278 return octave_value_list();
12279 }
12280
12281
12282 SWIG_DEFUN( plot3d, _wrap_plot3d, _wrap_plot3d_texinfo ) {
12283 PLFLT *arg1 = (PLFLT *) 0 ;
12284 PLFLT *arg2 = (PLFLT *) 0 ;
12285 PLFLT *arg3 = (PLFLT *) 0 ;
12286 PLINT arg4 ;
12287 PLINT arg5 ;
12288 PLINT arg6 ;
12289 PLBOOL arg7 ;
12290 Matrix temp1 ;
12291 Matrix temp2 ;
12292 Matrix temp3 ;
12293 int val6 ;
12294 int ecode6 = 0 ;
12295 int val7 ;
12296 int ecode7 = 0 ;
12297 octave_value_list _out;
12298 octave_value_list *_outp=&_out;
12299 octave_value _outv;
12300
12301 if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
12302 SWIG_fail;
12303 }
12304 {
12305 if ( _n_dims( args(0) ) > 1 )
12306 {
12307 error( "argument must be a scalar or vector" ); SWIG_fail;
12308 }
12309 temp1 = args(0).matrix_value();
12310 arg1 = &temp1( 0, 0 );
12311 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12312 }
12313 {
12314 if ( _n_dims( args(1) ) > 1 )
12315 {
12316 error( "argument must be a scalar or vector" ); SWIG_fail;
12317 }
12318 temp2 = args(1).matrix_value();
12319 arg2 = &temp2( 0, 0 );
12320 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12321 }
12322 {
12323 if ( _n_dims( args(2) ) > 2 )
12324 {
12325 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12326 }
12327 if ( _dim( args(2), 0 ) != Xlen )
12328 {
12329 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12330 }
12331 if ( _dim( args(2), 1 ) != Ylen )
12332 {
12333 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12334 }
12335 temp3 = args(2).matrix_value();
12336 arg3 = &temp3( 0, 0 );
12337 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12338 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12339 }
12340 ecode6 = SWIG_AsVal_int(args(3), &val6);
12341 if (!SWIG_IsOK(ecode6)) {
12342 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
12343 }
12344 arg6 = static_cast< PLINT >(val6);
12345 ecode7 = SWIG_AsVal_int(args(4), &val7);
12346 if (!SWIG_IsOK(ecode7)) {
12347 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
12348 }
12349 arg7 = static_cast< PLBOOL >(val7);
12350 my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
12351 _outv = octave_value();
12352 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12353 {
12354
12355 }
12356 {
12357
12358 }
12359 {
12360
12361 }
12362 return _out;
12363 fail:
12364 {
12365
12366 }
12367 {
12368
12369 }
12370 {
12371
12372 }
12373 return octave_value_list();
12374 }
12375
12376
12377 SWIG_DEFUN( plot3dc, _wrap_plot3dc, _wrap_plot3dc_texinfo ) {
12378 PLFLT *arg1 = (PLFLT *) 0 ;
12379 PLFLT *arg2 = (PLFLT *) 0 ;
12380 PLFLT *arg3 = (PLFLT *) 0 ;
12381 PLINT arg4 ;
12382 PLINT arg5 ;
12383 PLINT arg6 ;
12384 PLFLT *arg7 = (PLFLT *) 0 ;
12385 PLINT arg8 ;
12386 Matrix temp1 ;
12387 Matrix temp2 ;
12388 Matrix temp3 ;
12389 int val6 ;
12390 int ecode6 = 0 ;
12391 Matrix temp7 ;
12392 octave_value_list _out;
12393 octave_value_list *_outp=&_out;
12394 octave_value _outv;
12395
12396 if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
12397 SWIG_fail;
12398 }
12399 {
12400 if ( _n_dims( args(0) ) > 1 )
12401 {
12402 error( "argument must be a scalar or vector" ); SWIG_fail;
12403 }
12404 temp1 = args(0).matrix_value();
12405 arg1 = &temp1( 0, 0 );
12406 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12407 }
12408 {
12409 if ( _n_dims( args(1) ) > 1 )
12410 {
12411 error( "argument must be a scalar or vector" ); SWIG_fail;
12412 }
12413 temp2 = args(1).matrix_value();
12414 arg2 = &temp2( 0, 0 );
12415 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12416 }
12417 {
12418 if ( _n_dims( args(2) ) > 2 )
12419 {
12420 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12421 }
12422 if ( _dim( args(2), 0 ) != Xlen )
12423 {
12424 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12425 }
12426 if ( _dim( args(2), 1 ) != Ylen )
12427 {
12428 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12429 }
12430 temp3 = args(2).matrix_value();
12431 arg3 = &temp3( 0, 0 );
12432 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12433 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12434 }
12435 ecode6 = SWIG_AsVal_int(args(3), &val6);
12436 if (!SWIG_IsOK(ecode6)) {
12437 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
12438 }
12439 arg6 = static_cast< PLINT >(val6);
12440 {
12441 if ( _n_dims( args(4) ) > 1 )
12442 {
12443 error( "argument must be a scalar or vector" ); SWIG_fail;
12444 }
12445 temp7 = args(4).matrix_value();
12446 arg7 = &temp7( 0, 0 );
12447 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12448 }
12449 my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12450 _outv = octave_value();
12451 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12452 {
12453
12454 }
12455 {
12456
12457 }
12458 {
12459
12460 }
12461 {
12462
12463 }
12464 return _out;
12465 fail:
12466 {
12467
12468 }
12469 {
12470
12471 }
12472 {
12473
12474 }
12475 {
12476
12477 }
12478 return octave_value_list();
12479 }
12480
12481
12482 SWIG_DEFUN( plot3dcl, _wrap_plot3dcl, _wrap_plot3dcl_texinfo ) {
12483 PLFLT *arg1 = (PLFLT *) 0 ;
12484 PLFLT *arg2 = (PLFLT *) 0 ;
12485 PLFLT *arg3 = (PLFLT *) 0 ;
12486 PLINT arg4 ;
12487 PLINT arg5 ;
12488 PLINT arg6 ;
12489 PLFLT *arg7 = (PLFLT *) 0 ;
12490 PLINT arg8 ;
12491 PLINT arg9 ;
12492 PLINT arg10 ;
12493 PLINT *arg11 = (PLINT *) 0 ;
12494 PLINT *arg12 = (PLINT *) 0 ;
12495 Matrix temp1 ;
12496 Matrix temp2 ;
12497 Matrix temp3 ;
12498 int val6 ;
12499 int ecode6 = 0 ;
12500 Matrix temp7 ;
12501 int val9 ;
12502 int ecode9 = 0 ;
12503 Matrix temp10 ;
12504 Matrix temp12 ;
12505 octave_value_list _out;
12506 octave_value_list *_outp=&_out;
12507 octave_value _outv;
12508
12509 if (!SWIG_check_num_args("plot3dcl",args.length(),8,8,0)) {
12510 SWIG_fail;
12511 }
12512 {
12513 if ( _n_dims( args(0) ) > 1 )
12514 {
12515 error( "argument must be a scalar or vector" ); SWIG_fail;
12516 }
12517 temp1 = args(0).matrix_value();
12518 arg1 = &temp1( 0, 0 );
12519 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12520 }
12521 {
12522 if ( _n_dims( args(1) ) > 1 )
12523 {
12524 error( "argument must be a scalar or vector" ); SWIG_fail;
12525 }
12526 temp2 = args(1).matrix_value();
12527 arg2 = &temp2( 0, 0 );
12528 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12529 }
12530 {
12531 if ( _n_dims( args(2) ) > 2 )
12532 {
12533 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12534 }
12535 if ( _dim( args(2), 0 ) != Xlen )
12536 {
12537 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12538 }
12539 if ( _dim( args(2), 1 ) != Ylen )
12540 {
12541 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12542 }
12543 temp3 = args(2).matrix_value();
12544 arg3 = &temp3( 0, 0 );
12545 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12546 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12547 }
12548 ecode6 = SWIG_AsVal_int(args(3), &val6);
12549 if (!SWIG_IsOK(ecode6)) {
12550 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dcl" "', argument " "6"" of type '" "PLINT""'");
12551 }
12552 arg6 = static_cast< PLINT >(val6);
12553 {
12554 if ( _n_dims( args(4) ) > 1 )
12555 {
12556 error( "argument must be a scalar or vector" ); SWIG_fail;
12557 }
12558 temp7 = args(4).matrix_value();
12559 arg7 = &temp7( 0, 0 );
12560 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12561 }
12562 ecode9 = SWIG_AsVal_int(args(5), &val9);
12563 if (!SWIG_IsOK(ecode9)) {
12564 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plot3dcl" "', argument " "9"" of type '" "PLINT""'");
12565 }
12566 arg9 = static_cast< PLINT >(val9);
12567 {
12568 if ( _n_dims( args(6) ) > 1 )
12569 {
12570 error( "argument must be a scalar or vector" ); SWIG_fail;
12571 }
12572 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12573 arg11 = new PLINT[Alen];
12574 temp10 = args(6).matrix_value();
12575 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12576 }
12577 {
12578 if ( _n_dims( args(7) ) > 1 )
12579 {
12580 error( "argument must be a scalar or vector" ); SWIG_fail;
12581 }
12582 if ( _dim( args(7), 0 ) != Alen )
12583 {
12584 error( "argument vectors must be same length" ); SWIG_fail;
12585 }
12586 temp12 = args(7).matrix_value();
12587 arg12 = new PLINT[Alen];
12588 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12589 }
12590 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);
12591 _outv = octave_value();
12592 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12593 {
12594
12595 }
12596 {
12597
12598 }
12599 {
12600
12601 }
12602 {
12603
12604 }
12605 {
12606 delete [] arg11;
12607 }
12608 {
12609 delete [] arg12;
12610 }
12611 return _out;
12612 fail:
12613 {
12614
12615 }
12616 {
12617
12618 }
12619 {
12620
12621 }
12622 {
12623
12624 }
12625 {
12626 delete [] arg11;
12627 }
12628 {
12629 delete [] arg12;
12630 }
12631 return octave_value_list();
12632 }
12633
12634
12635 SWIG_DEFUN( plsurf3d, _wrap_plsurf3d, _wrap_plsurf3d_texinfo ) {
12636 PLFLT *arg1 = (PLFLT *) 0 ;
12637 PLFLT *arg2 = (PLFLT *) 0 ;
12638 PLFLT *arg3 = (PLFLT *) 0 ;
12639 PLINT arg4 ;
12640 PLINT arg5 ;
12641 PLINT arg6 ;
12642 PLFLT *arg7 = (PLFLT *) 0 ;
12643 PLINT arg8 ;
12644 Matrix temp1 ;
12645 Matrix temp2 ;
12646 Matrix temp3 ;
12647 int val6 ;
12648 int ecode6 = 0 ;
12649 Matrix temp7 ;
12650 octave_value_list _out;
12651 octave_value_list *_outp=&_out;
12652 octave_value _outv;
12653
12654 if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
12655 SWIG_fail;
12656 }
12657 {
12658 if ( _n_dims( args(0) ) > 1 )
12659 {
12660 error( "argument must be a scalar or vector" ); SWIG_fail;
12661 }
12662 temp1 = args(0).matrix_value();
12663 arg1 = &temp1( 0, 0 );
12664 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12665 }
12666 {
12667 if ( _n_dims( args(1) ) > 1 )
12668 {
12669 error( "argument must be a scalar or vector" ); SWIG_fail;
12670 }
12671 temp2 = args(1).matrix_value();
12672 arg2 = &temp2( 0, 0 );
12673 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12674 }
12675 {
12676 if ( _n_dims( args(2) ) > 2 )
12677 {
12678 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12679 }
12680 if ( _dim( args(2), 0 ) != Xlen )
12681 {
12682 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12683 }
12684 if ( _dim( args(2), 1 ) != Ylen )
12685 {
12686 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12687 }
12688 temp3 = args(2).matrix_value();
12689 arg3 = &temp3( 0, 0 );
12690 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12691 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12692 }
12693 ecode6 = SWIG_AsVal_int(args(3), &val6);
12694 if (!SWIG_IsOK(ecode6)) {
12695 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
12696 }
12697 arg6 = static_cast< PLINT >(val6);
12698 {
12699 if ( _n_dims( args(4) ) > 1 )
12700 {
12701 error( "argument must be a scalar or vector" ); SWIG_fail;
12702 }
12703 temp7 = args(4).matrix_value();
12704 arg7 = &temp7( 0, 0 );
12705 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12706 }
12707 my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
12708 _outv = octave_value();
12709 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12710 {
12711
12712 }
12713 {
12714
12715 }
12716 {
12717
12718 }
12719 {
12720
12721 }
12722 return _out;
12723 fail:
12724 {
12725
12726 }
12727 {
12728
12729 }
12730 {
12731
12732 }
12733 {
12734
12735 }
12736 return octave_value_list();
12737 }
12738
12739
12740 SWIG_DEFUN( plsurf3dl, _wrap_plsurf3dl, _wrap_plsurf3dl_texinfo ) {
12741 PLFLT *arg1 = (PLFLT *) 0 ;
12742 PLFLT *arg2 = (PLFLT *) 0 ;
12743 PLFLT *arg3 = (PLFLT *) 0 ;
12744 PLINT arg4 ;
12745 PLINT arg5 ;
12746 PLINT arg6 ;
12747 PLFLT *arg7 = (PLFLT *) 0 ;
12748 PLINT arg8 ;
12749 PLINT arg9 ;
12750 PLINT arg10 ;
12751 PLINT *arg11 = (PLINT *) 0 ;
12752 PLINT *arg12 = (PLINT *) 0 ;
12753 Matrix temp1 ;
12754 Matrix temp2 ;
12755 Matrix temp3 ;
12756 int val6 ;
12757 int ecode6 = 0 ;
12758 Matrix temp7 ;
12759 int val9 ;
12760 int ecode9 = 0 ;
12761 Matrix temp10 ;
12762 Matrix temp12 ;
12763 octave_value_list _out;
12764 octave_value_list *_outp=&_out;
12765 octave_value _outv;
12766
12767 if (!SWIG_check_num_args("plsurf3dl",args.length(),8,8,0)) {
12768 SWIG_fail;
12769 }
12770 {
12771 if ( _n_dims( args(0) ) > 1 )
12772 {
12773 error( "argument must be a scalar or vector" ); SWIG_fail;
12774 }
12775 temp1 = args(0).matrix_value();
12776 arg1 = &temp1( 0, 0 );
12777 Xlen = (PLINT) ( _dim( args(0), 0 ) );
12778 }
12779 {
12780 if ( _n_dims( args(1) ) > 1 )
12781 {
12782 error( "argument must be a scalar or vector" ); SWIG_fail;
12783 }
12784 temp2 = args(1).matrix_value();
12785 arg2 = &temp2( 0, 0 );
12786 Ylen = (PLINT) ( _dim( args(1), 0 ) );
12787 }
12788 {
12789 if ( _n_dims( args(2) ) > 2 )
12790 {
12791 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12792 }
12793 if ( _dim( args(2), 0 ) != Xlen )
12794 {
12795 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12796 }
12797 if ( _dim( args(2), 1 ) != Ylen )
12798 {
12799 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12800 }
12801 temp3 = args(2).matrix_value();
12802 arg3 = &temp3( 0, 0 );
12803 arg4 = (PLINT) ( _dim( args(2), 0 ) );
12804 arg5 = (PLINT) ( _dim( args(2), 1 ) );
12805 }
12806 ecode6 = SWIG_AsVal_int(args(3), &val6);
12807 if (!SWIG_IsOK(ecode6)) {
12808 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3dl" "', argument " "6"" of type '" "PLINT""'");
12809 }
12810 arg6 = static_cast< PLINT >(val6);
12811 {
12812 if ( _n_dims( args(4) ) > 1 )
12813 {
12814 error( "argument must be a scalar or vector" ); SWIG_fail;
12815 }
12816 temp7 = args(4).matrix_value();
12817 arg7 = &temp7( 0, 0 );
12818 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
12819 }
12820 ecode9 = SWIG_AsVal_int(args(5), &val9);
12821 if (!SWIG_IsOK(ecode9)) {
12822 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plsurf3dl" "', argument " "9"" of type '" "PLINT""'");
12823 }
12824 arg9 = static_cast< PLINT >(val9);
12825 {
12826 if ( _n_dims( args(6) ) > 1 )
12827 {
12828 error( "argument must be a scalar or vector" ); SWIG_fail;
12829 }
12830 arg10 = Alen = (PLINT) ( _dim( args(6), 0 ) );
12831 arg11 = new PLINT[Alen];
12832 temp10 = args(6).matrix_value();
12833 _cvt_double_to( arg11, &temp10( 0, 0 ), Alen );
12834 }
12835 {
12836 if ( _n_dims( args(7) ) > 1 )
12837 {
12838 error( "argument must be a scalar or vector" ); SWIG_fail;
12839 }
12840 if ( _dim( args(7), 0 ) != Alen )
12841 {
12842 error( "argument vectors must be same length" ); SWIG_fail;
12843 }
12844 temp12 = args(7).matrix_value();
12845 arg12 = new PLINT[Alen];
12846 _cvt_double_to( arg12, &temp12( 0, 0 ), Alen );
12847 }
12848 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);
12849 _outv = octave_value();
12850 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12851 {
12852
12853 }
12854 {
12855
12856 }
12857 {
12858
12859 }
12860 {
12861
12862 }
12863 {
12864 delete [] arg11;
12865 }
12866 {
12867 delete [] arg12;
12868 }
12869 return _out;
12870 fail:
12871 {
12872
12873 }
12874 {
12875
12876 }
12877 {
12878
12879 }
12880 {
12881
12882 }
12883 {
12884 delete [] arg11;
12885 }
12886 {
12887 delete [] arg12;
12888 }
12889 return octave_value_list();
12890 }
12891
12892
12893 SWIG_DEFUN( plshade, _wrap_plshade, _wrap_plshade_texinfo ) {
12894 PLFLT *arg1 = (PLFLT *) 0 ;
12895 PLINT arg2 ;
12896 PLINT arg3 ;
12897 PLFLT *arg4 = (PLFLT *) 0 ;
12898 PLFLT arg5 ;
12899 PLFLT arg6 ;
12900 PLFLT arg7 ;
12901 PLFLT arg8 ;
12902 PLFLT arg9 ;
12903 PLFLT arg10 ;
12904 PLINT arg11 ;
12905 PLFLT arg12 ;
12906 PLINT arg13 ;
12907 PLINT arg14 ;
12908 PLINT arg15 ;
12909 PLINT arg16 ;
12910 PLINT arg17 ;
12911 PLBOOL arg18 ;
12912 PLFLT *arg19 = (PLFLT *) 0 ;
12913 Matrix temp1 ;
12914 Matrix temp4 ;
12915 double val5 ;
12916 int ecode5 = 0 ;
12917 double val6 ;
12918 int ecode6 = 0 ;
12919 double val7 ;
12920 int ecode7 = 0 ;
12921 double val8 ;
12922 int ecode8 = 0 ;
12923 double val9 ;
12924 int ecode9 = 0 ;
12925 double val10 ;
12926 int ecode10 = 0 ;
12927 int val11 ;
12928 int ecode11 = 0 ;
12929 double val12 ;
12930 int ecode12 = 0 ;
12931 int val13 ;
12932 int ecode13 = 0 ;
12933 int val14 ;
12934 int ecode14 = 0 ;
12935 int val15 ;
12936 int ecode15 = 0 ;
12937 int val16 ;
12938 int ecode16 = 0 ;
12939 int val17 ;
12940 int ecode17 = 0 ;
12941 int val18 ;
12942 int ecode18 = 0 ;
12943 Matrix temp19 ;
12944 octave_value_list _out;
12945 octave_value_list *_outp=&_out;
12946 octave_value _outv;
12947
12948 if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
12949 SWIG_fail;
12950 }
12951 {
12952 if ( _n_dims( args(0) ) > 2 )
12953 {
12954 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12955 }
12956 temp1 = args(0).matrix_value();
12957 arg1 = &temp1( 0, 0 );
12958 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
12959 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
12960 }
12961 {
12962 if ( _n_dims( args(1) ) > 1 )
12963 {
12964 error( "argument must be a scalar or vector" ); SWIG_fail;
12965 }
12966 Alen = (PLINT) ( _dim( args(1), 0 ) );
12967 temp4 = args(1).matrix_value();
12968 arg4 = &temp4( 0, 0 );
12969 }
12970 ecode5 = SWIG_AsVal_double(args(2), &val5);
12971 if (!SWIG_IsOK(ecode5)) {
12972 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
12973 }
12974 arg5 = static_cast< PLFLT >(val5);
12975 ecode6 = SWIG_AsVal_double(args(3), &val6);
12976 if (!SWIG_IsOK(ecode6)) {
12977 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
12978 }
12979 arg6 = static_cast< PLFLT >(val6);
12980 ecode7 = SWIG_AsVal_double(args(4), &val7);
12981 if (!SWIG_IsOK(ecode7)) {
12982 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
12983 }
12984 arg7 = static_cast< PLFLT >(val7);
12985 ecode8 = SWIG_AsVal_double(args(5), &val8);
12986 if (!SWIG_IsOK(ecode8)) {
12987 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
12988 }
12989 arg8 = static_cast< PLFLT >(val8);
12990 ecode9 = SWIG_AsVal_double(args(6), &val9);
12991 if (!SWIG_IsOK(ecode9)) {
12992 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
12993 }
12994 arg9 = static_cast< PLFLT >(val9);
12995 ecode10 = SWIG_AsVal_double(args(7), &val10);
12996 if (!SWIG_IsOK(ecode10)) {
12997 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
12998 }
12999 arg10 = static_cast< PLFLT >(val10);
13000 ecode11 = SWIG_AsVal_int(args(8), &val11);
13001 if (!SWIG_IsOK(ecode11)) {
13002 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
13003 }
13004 arg11 = static_cast< PLINT >(val11);
13005 ecode12 = SWIG_AsVal_double(args(9), &val12);
13006 if (!SWIG_IsOK(ecode12)) {
13007 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
13008 }
13009 arg12 = static_cast< PLFLT >(val12);
13010 ecode13 = SWIG_AsVal_int(args(10), &val13);
13011 if (!SWIG_IsOK(ecode13)) {
13012 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
13013 }
13014 arg13 = static_cast< PLINT >(val13);
13015 ecode14 = SWIG_AsVal_int(args(11), &val14);
13016 if (!SWIG_IsOK(ecode14)) {
13017 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
13018 }
13019 arg14 = static_cast< PLINT >(val14);
13020 ecode15 = SWIG_AsVal_int(args(12), &val15);
13021 if (!SWIG_IsOK(ecode15)) {
13022 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
13023 }
13024 arg15 = static_cast< PLINT >(val15);
13025 ecode16 = SWIG_AsVal_int(args(13), &val16);
13026 if (!SWIG_IsOK(ecode16)) {
13027 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
13028 }
13029 arg16 = static_cast< PLINT >(val16);
13030 ecode17 = SWIG_AsVal_int(args(14), &val17);
13031 if (!SWIG_IsOK(ecode17)) {
13032 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
13033 }
13034 arg17 = static_cast< PLINT >(val17);
13035 ecode18 = SWIG_AsVal_int(args(15), &val18);
13036 if (!SWIG_IsOK(ecode18)) {
13037 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
13038 }
13039 arg18 = static_cast< PLBOOL >(val18);
13040 {
13041 if ( _n_dims( args(16) ) > 1 )
13042 {
13043 error( "argument must be a scalar or vector" ); SWIG_fail;
13044 }
13045 if ( _dim( args(16), 0 ) != 6 )
13046 {
13047 error( "argument vectors must have length of 6" ); SWIG_fail;
13048 }
13049 temp19 = args(16).matrix_value();
13050 arg19 = &temp19( 0, 0 );
13051 }
13052 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);
13053 _outv = octave_value();
13054 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13055 {
13056
13057 }
13058 {
13059
13060 }
13061 {
13062
13063 }
13064 return _out;
13065 fail:
13066 {
13067
13068 }
13069 {
13070
13071 }
13072 {
13073
13074 }
13075 return octave_value_list();
13076 }
13077
13078
13079 SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
13080 PLFLT *arg1 = (PLFLT *) 0 ;
13081 PLINT arg2 ;
13082 PLINT arg3 ;
13083 char *arg4 = (char *) 0 ;
13084 PLFLT arg5 ;
13085 PLFLT arg6 ;
13086 PLFLT arg7 ;
13087 PLFLT arg8 ;
13088 PLFLT arg9 ;
13089 PLFLT arg10 ;
13090 PLINT arg11 ;
13091 PLFLT arg12 ;
13092 PLINT arg13 ;
13093 PLINT arg14 ;
13094 PLINT arg15 ;
13095 PLINT arg16 ;
13096 PLINT arg17 ;
13097 PLBOOL arg18 ;
13098 PLFLT *arg19 = (PLFLT *) 0 ;
13099 PLFLT *arg20 = (PLFLT *) 0 ;
13100 Matrix temp1 ;
13101 int res4 ;
13102 char *buf4 = 0 ;
13103 int alloc4 = 0 ;
13104 double val5 ;
13105 int ecode5 = 0 ;
13106 double val6 ;
13107 int ecode6 = 0 ;
13108 double val7 ;
13109 int ecode7 = 0 ;
13110 double val8 ;
13111 int ecode8 = 0 ;
13112 double val9 ;
13113 int ecode9 = 0 ;
13114 double val10 ;
13115 int ecode10 = 0 ;
13116 int val11 ;
13117 int ecode11 = 0 ;
13118 double val12 ;
13119 int ecode12 = 0 ;
13120 int val13 ;
13121 int ecode13 = 0 ;
13122 int val14 ;
13123 int ecode14 = 0 ;
13124 int val15 ;
13125 int ecode15 = 0 ;
13126 int val16 ;
13127 int ecode16 = 0 ;
13128 int val17 ;
13129 int ecode17 = 0 ;
13130 int val18 ;
13131 int ecode18 = 0 ;
13132 Matrix temp19 ;
13133 Matrix temp20 ;
13134 octave_value_list _out;
13135 octave_value_list *_outp=&_out;
13136 octave_value _outv;
13137
13138 if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
13139 SWIG_fail;
13140 }
13141 {
13142 if ( _n_dims( args(0) ) > 2 )
13143 {
13144 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13145 }
13146 temp1 = args(0).matrix_value();
13147 arg1 = &temp1( 0, 0 );
13148 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13149 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13150 }
13151 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13152 if (!SWIG_IsOK(res4)) {
13153 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
13154 }
13155 arg4 = reinterpret_cast< char * >(buf4);
13156 ecode5 = SWIG_AsVal_double(args(2), &val5);
13157 if (!SWIG_IsOK(ecode5)) {
13158 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
13159 }
13160 arg5 = static_cast< PLFLT >(val5);
13161 ecode6 = SWIG_AsVal_double(args(3), &val6);
13162 if (!SWIG_IsOK(ecode6)) {
13163 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
13164 }
13165 arg6 = static_cast< PLFLT >(val6);
13166 ecode7 = SWIG_AsVal_double(args(4), &val7);
13167 if (!SWIG_IsOK(ecode7)) {
13168 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
13169 }
13170 arg7 = static_cast< PLFLT >(val7);
13171 ecode8 = SWIG_AsVal_double(args(5), &val8);
13172 if (!SWIG_IsOK(ecode8)) {
13173 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
13174 }
13175 arg8 = static_cast< PLFLT >(val8);
13176 ecode9 = SWIG_AsVal_double(args(6), &val9);
13177 if (!SWIG_IsOK(ecode9)) {
13178 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
13179 }
13180 arg9 = static_cast< PLFLT >(val9);
13181 ecode10 = SWIG_AsVal_double(args(7), &val10);
13182 if (!SWIG_IsOK(ecode10)) {
13183 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
13184 }
13185 arg10 = static_cast< PLFLT >(val10);
13186 ecode11 = SWIG_AsVal_int(args(8), &val11);
13187 if (!SWIG_IsOK(ecode11)) {
13188 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
13189 }
13190 arg11 = static_cast< PLINT >(val11);
13191 ecode12 = SWIG_AsVal_double(args(9), &val12);
13192 if (!SWIG_IsOK(ecode12)) {
13193 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
13194 }
13195 arg12 = static_cast< PLFLT >(val12);
13196 ecode13 = SWIG_AsVal_int(args(10), &val13);
13197 if (!SWIG_IsOK(ecode13)) {
13198 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
13199 }
13200 arg13 = static_cast< PLINT >(val13);
13201 ecode14 = SWIG_AsVal_int(args(11), &val14);
13202 if (!SWIG_IsOK(ecode14)) {
13203 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
13204 }
13205 arg14 = static_cast< PLINT >(val14);
13206 ecode15 = SWIG_AsVal_int(args(12), &val15);
13207 if (!SWIG_IsOK(ecode15)) {
13208 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
13209 }
13210 arg15 = static_cast< PLINT >(val15);
13211 ecode16 = SWIG_AsVal_int(args(13), &val16);
13212 if (!SWIG_IsOK(ecode16)) {
13213 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
13214 }
13215 arg16 = static_cast< PLINT >(val16);
13216 ecode17 = SWIG_AsVal_int(args(14), &val17);
13217 if (!SWIG_IsOK(ecode17)) {
13218 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
13219 }
13220 arg17 = static_cast< PLINT >(val17);
13221 ecode18 = SWIG_AsVal_int(args(15), &val18);
13222 if (!SWIG_IsOK(ecode18)) {
13223 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
13224 }
13225 arg18 = static_cast< PLBOOL >(val18);
13226 {
13227 if ( _n_dims( args(16) ) > 1 )
13228 {
13229 error( "argument must be a scalar or vector" ); SWIG_fail;
13230 }
13231 if ( _dim( args(16), 0 ) != Xlen )
13232 {
13233 error( "argument vectors must be same length" ); SWIG_fail;
13234 }
13235 temp19 = args(16).matrix_value();
13236 arg19 = &temp19( 0, 0 );
13237 }
13238 {
13239 if ( _n_dims( args(17) ) > 1 )
13240 {
13241 error( "argument must be a scalar or vector" ); SWIG_fail;
13242 }
13243 if ( _dim( args(17), 0 ) != Ylen )
13244 {
13245 error( "argument vectors must be same length" ); SWIG_fail;
13246 }
13247 temp20 = args(17).matrix_value();
13248 arg20 = &temp20( 0, 0 );
13249 }
13250 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);
13251 _outv = octave_value();
13252 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13253 {
13254
13255 }
13256 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13257 {
13258
13259 }
13260 {
13261
13262 }
13263 return _out;
13264 fail:
13265 {
13266
13267 }
13268 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13269 {
13270
13271 }
13272 {
13273
13274 }
13275 return octave_value_list();
13276 }
13277
13278
13279 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
13280 PLFLT *arg1 = (PLFLT *) 0 ;
13281 PLINT arg2 ;
13282 PLINT arg3 ;
13283 char *arg4 = (char *) 0 ;
13284 PLFLT arg5 ;
13285 PLFLT arg6 ;
13286 PLFLT arg7 ;
13287 PLFLT arg8 ;
13288 PLFLT arg9 ;
13289 PLFLT arg10 ;
13290 PLINT arg11 ;
13291 PLFLT arg12 ;
13292 PLINT arg13 ;
13293 PLINT arg14 ;
13294 PLINT arg15 ;
13295 PLINT arg16 ;
13296 PLINT arg17 ;
13297 PLBOOL arg18 ;
13298 PLFLT *arg19 = (PLFLT *) 0 ;
13299 PLFLT *arg20 = (PLFLT *) 0 ;
13300 Matrix temp1 ;
13301 int res4 ;
13302 char *buf4 = 0 ;
13303 int alloc4 = 0 ;
13304 double val5 ;
13305 int ecode5 = 0 ;
13306 double val6 ;
13307 int ecode6 = 0 ;
13308 double val7 ;
13309 int ecode7 = 0 ;
13310 double val8 ;
13311 int ecode8 = 0 ;
13312 double val9 ;
13313 int ecode9 = 0 ;
13314 double val10 ;
13315 int ecode10 = 0 ;
13316 int val11 ;
13317 int ecode11 = 0 ;
13318 double val12 ;
13319 int ecode12 = 0 ;
13320 int val13 ;
13321 int ecode13 = 0 ;
13322 int val14 ;
13323 int ecode14 = 0 ;
13324 int val15 ;
13325 int ecode15 = 0 ;
13326 int val16 ;
13327 int ecode16 = 0 ;
13328 int val17 ;
13329 int ecode17 = 0 ;
13330 int val18 ;
13331 int ecode18 = 0 ;
13332 Matrix temp19 ;
13333 Matrix temp20 ;
13334 octave_value_list _out;
13335 octave_value_list *_outp=&_out;
13336 octave_value _outv;
13337
13338 if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
13339 SWIG_fail;
13340 }
13341 {
13342 if ( _n_dims( args(0) ) > 2 )
13343 {
13344 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13345 }
13346 temp1 = args(0).matrix_value();
13347 arg1 = &temp1( 0, 0 );
13348 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13349 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13350 }
13351 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
13352 if (!SWIG_IsOK(res4)) {
13353 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
13354 }
13355 arg4 = reinterpret_cast< char * >(buf4);
13356 ecode5 = SWIG_AsVal_double(args(2), &val5);
13357 if (!SWIG_IsOK(ecode5)) {
13358 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
13359 }
13360 arg5 = static_cast< PLFLT >(val5);
13361 ecode6 = SWIG_AsVal_double(args(3), &val6);
13362 if (!SWIG_IsOK(ecode6)) {
13363 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
13364 }
13365 arg6 = static_cast< PLFLT >(val6);
13366 ecode7 = SWIG_AsVal_double(args(4), &val7);
13367 if (!SWIG_IsOK(ecode7)) {
13368 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
13369 }
13370 arg7 = static_cast< PLFLT >(val7);
13371 ecode8 = SWIG_AsVal_double(args(5), &val8);
13372 if (!SWIG_IsOK(ecode8)) {
13373 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
13374 }
13375 arg8 = static_cast< PLFLT >(val8);
13376 ecode9 = SWIG_AsVal_double(args(6), &val9);
13377 if (!SWIG_IsOK(ecode9)) {
13378 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
13379 }
13380 arg9 = static_cast< PLFLT >(val9);
13381 ecode10 = SWIG_AsVal_double(args(7), &val10);
13382 if (!SWIG_IsOK(ecode10)) {
13383 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
13384 }
13385 arg10 = static_cast< PLFLT >(val10);
13386 ecode11 = SWIG_AsVal_int(args(8), &val11);
13387 if (!SWIG_IsOK(ecode11)) {
13388 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
13389 }
13390 arg11 = static_cast< PLINT >(val11);
13391 ecode12 = SWIG_AsVal_double(args(9), &val12);
13392 if (!SWIG_IsOK(ecode12)) {
13393 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
13394 }
13395 arg12 = static_cast< PLFLT >(val12);
13396 ecode13 = SWIG_AsVal_int(args(10), &val13);
13397 if (!SWIG_IsOK(ecode13)) {
13398 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
13399 }
13400 arg13 = static_cast< PLINT >(val13);
13401 ecode14 = SWIG_AsVal_int(args(11), &val14);
13402 if (!SWIG_IsOK(ecode14)) {
13403 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
13404 }
13405 arg14 = static_cast< PLINT >(val14);
13406 ecode15 = SWIG_AsVal_int(args(12), &val15);
13407 if (!SWIG_IsOK(ecode15)) {
13408 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
13409 }
13410 arg15 = static_cast< PLINT >(val15);
13411 ecode16 = SWIG_AsVal_int(args(13), &val16);
13412 if (!SWIG_IsOK(ecode16)) {
13413 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
13414 }
13415 arg16 = static_cast< PLINT >(val16);
13416 ecode17 = SWIG_AsVal_int(args(14), &val17);
13417 if (!SWIG_IsOK(ecode17)) {
13418 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
13419 }
13420 arg17 = static_cast< PLINT >(val17);
13421 ecode18 = SWIG_AsVal_int(args(15), &val18);
13422 if (!SWIG_IsOK(ecode18)) {
13423 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
13424 }
13425 arg18 = static_cast< PLBOOL >(val18);
13426 {
13427 if ( _n_dims( args(16) ) > 2 )
13428 {
13429 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13430 }
13431 temp19 = args(16).matrix_value();
13432 arg19 = &temp19( 0, 0 );
13433 Xlen = (PLINT) ( _dim( args(16), 0 ) );
13434 Ylen = (PLINT) ( _dim( args(16), 1 ) );
13435 }
13436 {
13437 if ( _n_dims( args(17) ) > 2 )
13438 {
13439 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13440 }
13441 temp20 = args(17).matrix_value();
13442 arg20 = &temp20( 0, 0 );
13443 Xlen = (PLINT) ( _dim( args(17), 0 ) );
13444 Ylen = (PLINT) ( _dim( args(17), 1 ) );
13445 }
13446 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);
13447 _outv = octave_value();
13448 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13449 {
13450
13451 }
13452 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13453 {
13454
13455 }
13456 {
13457
13458 }
13459 return _out;
13460 fail:
13461 {
13462
13463 }
13464 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13465 {
13466
13467 }
13468 {
13469
13470 }
13471 return octave_value_list();
13472 }
13473
13474
13475 SWIG_DEFUN( plshades, _wrap_plshades, _wrap_plshades_texinfo ) {
13476 PLFLT *arg1 = (PLFLT *) 0 ;
13477 PLINT arg2 ;
13478 PLINT arg3 ;
13479 PLFLT arg4 ;
13480 PLFLT arg5 ;
13481 PLFLT arg6 ;
13482 PLFLT arg7 ;
13483 PLFLT *arg8 = (PLFLT *) 0 ;
13484 PLINT arg9 ;
13485 PLINT arg10 ;
13486 PLINT arg11 ;
13487 PLINT arg12 ;
13488 PLBOOL arg13 ;
13489 Matrix temp1 ;
13490 double val4 ;
13491 int ecode4 = 0 ;
13492 double val5 ;
13493 int ecode5 = 0 ;
13494 double val6 ;
13495 int ecode6 = 0 ;
13496 double val7 ;
13497 int ecode7 = 0 ;
13498 Matrix temp8 ;
13499 int val10 ;
13500 int ecode10 = 0 ;
13501 int val11 ;
13502 int ecode11 = 0 ;
13503 int val12 ;
13504 int ecode12 = 0 ;
13505 int val13 ;
13506 int ecode13 = 0 ;
13507 octave_value_list _out;
13508 octave_value_list *_outp=&_out;
13509 octave_value _outv;
13510
13511 if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
13512 SWIG_fail;
13513 }
13514 {
13515 if ( _n_dims( args(0) ) > 2 )
13516 {
13517 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13518 }
13519 temp1 = args(0).matrix_value();
13520 arg1 = &temp1( 0, 0 );
13521 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13522 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13523 }
13524 ecode4 = SWIG_AsVal_double(args(1), &val4);
13525 if (!SWIG_IsOK(ecode4)) {
13526 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
13527 }
13528 arg4 = static_cast< PLFLT >(val4);
13529 ecode5 = SWIG_AsVal_double(args(2), &val5);
13530 if (!SWIG_IsOK(ecode5)) {
13531 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
13532 }
13533 arg5 = static_cast< PLFLT >(val5);
13534 ecode6 = SWIG_AsVal_double(args(3), &val6);
13535 if (!SWIG_IsOK(ecode6)) {
13536 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
13537 }
13538 arg6 = static_cast< PLFLT >(val6);
13539 ecode7 = SWIG_AsVal_double(args(4), &val7);
13540 if (!SWIG_IsOK(ecode7)) {
13541 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
13542 }
13543 arg7 = static_cast< PLFLT >(val7);
13544 {
13545 if ( _n_dims( args(5) ) > 1 )
13546 {
13547 error( "argument must be a scalar or vector" ); SWIG_fail;
13548 }
13549 temp8 = args(5).matrix_value();
13550 arg8 = &temp8( 0, 0 );
13551 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13552 }
13553 ecode10 = SWIG_AsVal_int(args(6), &val10);
13554 if (!SWIG_IsOK(ecode10)) {
13555 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
13556 }
13557 arg10 = static_cast< PLINT >(val10);
13558 ecode11 = SWIG_AsVal_int(args(7), &val11);
13559 if (!SWIG_IsOK(ecode11)) {
13560 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
13561 }
13562 arg11 = static_cast< PLINT >(val11);
13563 ecode12 = SWIG_AsVal_int(args(8), &val12);
13564 if (!SWIG_IsOK(ecode12)) {
13565 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
13566 }
13567 arg12 = static_cast< PLINT >(val12);
13568 ecode13 = SWIG_AsVal_int(args(9), &val13);
13569 if (!SWIG_IsOK(ecode13)) {
13570 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
13571 }
13572 arg13 = static_cast< PLBOOL >(val13);
13573 my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
13574 _outv = octave_value();
13575 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13576 {
13577
13578 }
13579 {
13580
13581 }
13582 return _out;
13583 fail:
13584 {
13585
13586 }
13587 {
13588
13589 }
13590 return octave_value_list();
13591 }
13592
13593
13594 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
13595 PLFLT *arg1 = (PLFLT *) 0 ;
13596 PLINT arg2 ;
13597 PLINT arg3 ;
13598 PLFLT arg4 ;
13599 PLFLT arg5 ;
13600 PLFLT arg6 ;
13601 PLFLT arg7 ;
13602 PLFLT *arg8 = (PLFLT *) 0 ;
13603 PLINT arg9 ;
13604 PLINT arg10 ;
13605 PLINT arg11 ;
13606 PLINT arg12 ;
13607 PLBOOL arg13 ;
13608 PLFLT *arg14 = (PLFLT *) 0 ;
13609 Matrix temp1 ;
13610 double val4 ;
13611 int ecode4 = 0 ;
13612 double val5 ;
13613 int ecode5 = 0 ;
13614 double val6 ;
13615 int ecode6 = 0 ;
13616 double val7 ;
13617 int ecode7 = 0 ;
13618 Matrix temp8 ;
13619 int val10 ;
13620 int ecode10 = 0 ;
13621 int val11 ;
13622 int ecode11 = 0 ;
13623 int val12 ;
13624 int ecode12 = 0 ;
13625 int val13 ;
13626 int ecode13 = 0 ;
13627 Matrix temp14 ;
13628 octave_value_list _out;
13629 octave_value_list *_outp=&_out;
13630 octave_value _outv;
13631
13632 if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
13633 SWIG_fail;
13634 }
13635 {
13636 if ( _n_dims( args(0) ) > 2 )
13637 {
13638 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13639 }
13640 temp1 = args(0).matrix_value();
13641 arg1 = &temp1( 0, 0 );
13642 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13643 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13644 }
13645 ecode4 = SWIG_AsVal_double(args(1), &val4);
13646 if (!SWIG_IsOK(ecode4)) {
13647 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
13648 }
13649 arg4 = static_cast< PLFLT >(val4);
13650 ecode5 = SWIG_AsVal_double(args(2), &val5);
13651 if (!SWIG_IsOK(ecode5)) {
13652 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
13653 }
13654 arg5 = static_cast< PLFLT >(val5);
13655 ecode6 = SWIG_AsVal_double(args(3), &val6);
13656 if (!SWIG_IsOK(ecode6)) {
13657 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
13658 }
13659 arg6 = static_cast< PLFLT >(val6);
13660 ecode7 = SWIG_AsVal_double(args(4), &val7);
13661 if (!SWIG_IsOK(ecode7)) {
13662 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
13663 }
13664 arg7 = static_cast< PLFLT >(val7);
13665 {
13666 if ( _n_dims( args(5) ) > 1 )
13667 {
13668 error( "argument must be a scalar or vector" ); SWIG_fail;
13669 }
13670 temp8 = args(5).matrix_value();
13671 arg8 = &temp8( 0, 0 );
13672 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13673 }
13674 ecode10 = SWIG_AsVal_int(args(6), &val10);
13675 if (!SWIG_IsOK(ecode10)) {
13676 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
13677 }
13678 arg10 = static_cast< PLINT >(val10);
13679 ecode11 = SWIG_AsVal_int(args(7), &val11);
13680 if (!SWIG_IsOK(ecode11)) {
13681 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
13682 }
13683 arg11 = static_cast< PLINT >(val11);
13684 ecode12 = SWIG_AsVal_int(args(8), &val12);
13685 if (!SWIG_IsOK(ecode12)) {
13686 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
13687 }
13688 arg12 = static_cast< PLINT >(val12);
13689 ecode13 = SWIG_AsVal_int(args(9), &val13);
13690 if (!SWIG_IsOK(ecode13)) {
13691 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
13692 }
13693 arg13 = static_cast< PLBOOL >(val13);
13694 {
13695 if ( _n_dims( args(10) ) > 1 )
13696 {
13697 error( "argument must be a scalar or vector" ); SWIG_fail;
13698 }
13699 if ( _dim( args(10), 0 ) != 6 )
13700 {
13701 error( "argument vectors must have length of 6" ); SWIG_fail;
13702 }
13703 temp14 = args(10).matrix_value();
13704 arg14 = &temp14( 0, 0 );
13705 }
13706 my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
13707 _outv = octave_value();
13708 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13709 {
13710
13711 }
13712 {
13713
13714 }
13715 {
13716
13717 }
13718 return _out;
13719 fail:
13720 {
13721
13722 }
13723 {
13724
13725 }
13726 {
13727
13728 }
13729 return octave_value_list();
13730 }
13731
13732
13733 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
13734 PLFLT *arg1 = (PLFLT *) 0 ;
13735 PLINT arg2 ;
13736 PLINT arg3 ;
13737 PLFLT arg4 ;
13738 PLFLT arg5 ;
13739 PLFLT arg6 ;
13740 PLFLT arg7 ;
13741 PLFLT *arg8 = (PLFLT *) 0 ;
13742 PLINT arg9 ;
13743 PLINT arg10 ;
13744 PLINT arg11 ;
13745 PLINT arg12 ;
13746 PLBOOL arg13 ;
13747 PLFLT *arg14 = (PLFLT *) 0 ;
13748 PLFLT *arg15 = (PLFLT *) 0 ;
13749 Matrix temp1 ;
13750 double val4 ;
13751 int ecode4 = 0 ;
13752 double val5 ;
13753 int ecode5 = 0 ;
13754 double val6 ;
13755 int ecode6 = 0 ;
13756 double val7 ;
13757 int ecode7 = 0 ;
13758 Matrix temp8 ;
13759 int val10 ;
13760 int ecode10 = 0 ;
13761 int val11 ;
13762 int ecode11 = 0 ;
13763 int val12 ;
13764 int ecode12 = 0 ;
13765 int val13 ;
13766 int ecode13 = 0 ;
13767 Matrix temp14 ;
13768 Matrix temp15 ;
13769 octave_value_list _out;
13770 octave_value_list *_outp=&_out;
13771 octave_value _outv;
13772
13773 if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
13774 SWIG_fail;
13775 }
13776 {
13777 if ( _n_dims( args(0) ) > 2 )
13778 {
13779 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13780 }
13781 temp1 = args(0).matrix_value();
13782 arg1 = &temp1( 0, 0 );
13783 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13784 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13785 }
13786 ecode4 = SWIG_AsVal_double(args(1), &val4);
13787 if (!SWIG_IsOK(ecode4)) {
13788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
13789 }
13790 arg4 = static_cast< PLFLT >(val4);
13791 ecode5 = SWIG_AsVal_double(args(2), &val5);
13792 if (!SWIG_IsOK(ecode5)) {
13793 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
13794 }
13795 arg5 = static_cast< PLFLT >(val5);
13796 ecode6 = SWIG_AsVal_double(args(3), &val6);
13797 if (!SWIG_IsOK(ecode6)) {
13798 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
13799 }
13800 arg6 = static_cast< PLFLT >(val6);
13801 ecode7 = SWIG_AsVal_double(args(4), &val7);
13802 if (!SWIG_IsOK(ecode7)) {
13803 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
13804 }
13805 arg7 = static_cast< PLFLT >(val7);
13806 {
13807 if ( _n_dims( args(5) ) > 1 )
13808 {
13809 error( "argument must be a scalar or vector" ); SWIG_fail;
13810 }
13811 temp8 = args(5).matrix_value();
13812 arg8 = &temp8( 0, 0 );
13813 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13814 }
13815 ecode10 = SWIG_AsVal_int(args(6), &val10);
13816 if (!SWIG_IsOK(ecode10)) {
13817 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
13818 }
13819 arg10 = static_cast< PLINT >(val10);
13820 ecode11 = SWIG_AsVal_int(args(7), &val11);
13821 if (!SWIG_IsOK(ecode11)) {
13822 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
13823 }
13824 arg11 = static_cast< PLINT >(val11);
13825 ecode12 = SWIG_AsVal_int(args(8), &val12);
13826 if (!SWIG_IsOK(ecode12)) {
13827 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
13828 }
13829 arg12 = static_cast< PLINT >(val12);
13830 ecode13 = SWIG_AsVal_int(args(9), &val13);
13831 if (!SWIG_IsOK(ecode13)) {
13832 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
13833 }
13834 arg13 = static_cast< PLBOOL >(val13);
13835 {
13836 if ( _n_dims( args(10) ) > 1 )
13837 {
13838 error( "argument must be a scalar or vector" ); SWIG_fail;
13839 }
13840 if ( _dim( args(10), 0 ) != Xlen )
13841 {
13842 error( "argument vectors must be same length" ); SWIG_fail;
13843 }
13844 temp14 = args(10).matrix_value();
13845 arg14 = &temp14( 0, 0 );
13846 }
13847 {
13848 if ( _n_dims( args(11) ) > 1 )
13849 {
13850 error( "argument must be a scalar or vector" ); SWIG_fail;
13851 }
13852 if ( _dim( args(11), 0 ) != Ylen )
13853 {
13854 error( "argument vectors must be same length" ); SWIG_fail;
13855 }
13856 temp15 = args(11).matrix_value();
13857 arg15 = &temp15( 0, 0 );
13858 }
13859 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);
13860 _outv = octave_value();
13861 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13862 {
13863
13864 }
13865 {
13866
13867 }
13868 {
13869
13870 }
13871 {
13872
13873 }
13874 return _out;
13875 fail:
13876 {
13877
13878 }
13879 {
13880
13881 }
13882 {
13883
13884 }
13885 {
13886
13887 }
13888 return octave_value_list();
13889 }
13890
13891
13892 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
13893 PLFLT *arg1 = (PLFLT *) 0 ;
13894 PLINT arg2 ;
13895 PLINT arg3 ;
13896 PLFLT arg4 ;
13897 PLFLT arg5 ;
13898 PLFLT arg6 ;
13899 PLFLT arg7 ;
13900 PLFLT *arg8 = (PLFLT *) 0 ;
13901 PLINT arg9 ;
13902 PLINT arg10 ;
13903 PLINT arg11 ;
13904 PLINT arg12 ;
13905 PLBOOL arg13 ;
13906 PLFLT *arg14 = (PLFLT *) 0 ;
13907 PLFLT *arg15 = (PLFLT *) 0 ;
13908 Matrix temp1 ;
13909 double val4 ;
13910 int ecode4 = 0 ;
13911 double val5 ;
13912 int ecode5 = 0 ;
13913 double val6 ;
13914 int ecode6 = 0 ;
13915 double val7 ;
13916 int ecode7 = 0 ;
13917 Matrix temp8 ;
13918 int val10 ;
13919 int ecode10 = 0 ;
13920 int val11 ;
13921 int ecode11 = 0 ;
13922 int val12 ;
13923 int ecode12 = 0 ;
13924 int val13 ;
13925 int ecode13 = 0 ;
13926 Matrix temp14 ;
13927 Matrix temp15 ;
13928 octave_value_list _out;
13929 octave_value_list *_outp=&_out;
13930 octave_value _outv;
13931
13932 if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
13933 SWIG_fail;
13934 }
13935 {
13936 if ( _n_dims( args(0) ) > 2 )
13937 {
13938 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13939 }
13940 temp1 = args(0).matrix_value();
13941 arg1 = &temp1( 0, 0 );
13942 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
13943 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
13944 }
13945 ecode4 = SWIG_AsVal_double(args(1), &val4);
13946 if (!SWIG_IsOK(ecode4)) {
13947 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
13948 }
13949 arg4 = static_cast< PLFLT >(val4);
13950 ecode5 = SWIG_AsVal_double(args(2), &val5);
13951 if (!SWIG_IsOK(ecode5)) {
13952 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
13953 }
13954 arg5 = static_cast< PLFLT >(val5);
13955 ecode6 = SWIG_AsVal_double(args(3), &val6);
13956 if (!SWIG_IsOK(ecode6)) {
13957 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
13958 }
13959 arg6 = static_cast< PLFLT >(val6);
13960 ecode7 = SWIG_AsVal_double(args(4), &val7);
13961 if (!SWIG_IsOK(ecode7)) {
13962 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
13963 }
13964 arg7 = static_cast< PLFLT >(val7);
13965 {
13966 if ( _n_dims( args(5) ) > 1 )
13967 {
13968 error( "argument must be a scalar or vector" ); SWIG_fail;
13969 }
13970 temp8 = args(5).matrix_value();
13971 arg8 = &temp8( 0, 0 );
13972 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
13973 }
13974 ecode10 = SWIG_AsVal_int(args(6), &val10);
13975 if (!SWIG_IsOK(ecode10)) {
13976 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
13977 }
13978 arg10 = static_cast< PLINT >(val10);
13979 ecode11 = SWIG_AsVal_int(args(7), &val11);
13980 if (!SWIG_IsOK(ecode11)) {
13981 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
13982 }
13983 arg11 = static_cast< PLINT >(val11);
13984 ecode12 = SWIG_AsVal_int(args(8), &val12);
13985 if (!SWIG_IsOK(ecode12)) {
13986 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
13987 }
13988 arg12 = static_cast< PLINT >(val12);
13989 ecode13 = SWIG_AsVal_int(args(9), &val13);
13990 if (!SWIG_IsOK(ecode13)) {
13991 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
13992 }
13993 arg13 = static_cast< PLBOOL >(val13);
13994 {
13995 if ( _n_dims( args(10) ) > 2 )
13996 {
13997 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
13998 }
13999 temp14 = args(10).matrix_value();
14000 arg14 = &temp14( 0, 0 );
14001 Xlen = (PLINT) ( _dim( args(10), 0 ) );
14002 Ylen = (PLINT) ( _dim( args(10), 1 ) );
14003 }
14004 {
14005 if ( _n_dims( args(11) ) > 2 )
14006 {
14007 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14008 }
14009 temp15 = args(11).matrix_value();
14010 arg15 = &temp15( 0, 0 );
14011 Xlen = (PLINT) ( _dim( args(11), 0 ) );
14012 Ylen = (PLINT) ( _dim( args(11), 1 ) );
14013 }
14014 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);
14015 _outv = octave_value();
14016 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14017 {
14018
14019 }
14020 {
14021
14022 }
14023 {
14024
14025 }
14026 {
14027
14028 }
14029 return _out;
14030 fail:
14031 {
14032
14033 }
14034 {
14035
14036 }
14037 {
14038
14039 }
14040 {
14041
14042 }
14043 return octave_value_list();
14044 }
14045
14046
14047 SWIG_DEFUN( plvect, _wrap_plvect, _wrap_plvect_texinfo ) {
14048 PLFLT *arg1 = (PLFLT *) 0 ;
14049 PLFLT *arg2 = (PLFLT *) 0 ;
14050 PLINT arg3 ;
14051 PLINT arg4 ;
14052 PLFLT arg5 ;
14053 PLFLT *arg6 = (PLFLT *) 0 ;
14054 Matrix temp1 ;
14055 Matrix temp2 ;
14056 double val5 ;
14057 int ecode5 = 0 ;
14058 Matrix temp6 ;
14059 octave_value_list _out;
14060 octave_value_list *_outp=&_out;
14061 octave_value _outv;
14062
14063 if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
14064 SWIG_fail;
14065 }
14066 {
14067 if ( _n_dims( args(0) ) > 2 )
14068 {
14069 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14070 }
14071 temp1 = args(0).matrix_value();
14072 arg1 = &temp1( 0, 0 );
14073 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14074 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14075 }
14076 {
14077 if ( _n_dims( args(1) ) > 2 )
14078 {
14079 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14080 }
14081 if ( _dim( args(1), 0 ) != Xlen )
14082 {
14083 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14084 }
14085 if ( _dim( args(1), 1 ) != Ylen )
14086 {
14087 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14088 }
14089 temp2 = args(1).matrix_value();
14090 arg2 = &temp2( 0, 0 );
14091 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14092 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14093 }
14094 ecode5 = SWIG_AsVal_double(args(2), &val5);
14095 if (!SWIG_IsOK(ecode5)) {
14096 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
14097 }
14098 arg5 = static_cast< PLFLT >(val5);
14099 {
14100 if ( _n_dims( args(3) ) > 1 )
14101 {
14102 error( "argument must be a scalar or vector" ); SWIG_fail;
14103 }
14104 if ( _dim( args(3), 0 ) != 6 )
14105 {
14106 error( "argument vectors must have length of 6" ); SWIG_fail;
14107 }
14108 temp6 = args(3).matrix_value();
14109 arg6 = &temp6( 0, 0 );
14110 }
14111 my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
14112 _outv = octave_value();
14113 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14114 {
14115
14116 }
14117 {
14118
14119 }
14120 {
14121
14122 }
14123 return _out;
14124 fail:
14125 {
14126
14127 }
14128 {
14129
14130 }
14131 {
14132
14133 }
14134 return octave_value_list();
14135 }
14136
14137
14138 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
14139 PLFLT *arg1 = (PLFLT *) 0 ;
14140 PLFLT *arg2 = (PLFLT *) 0 ;
14141 PLINT arg3 ;
14142 PLINT arg4 ;
14143 PLFLT arg5 ;
14144 PLFLT *arg6 = (PLFLT *) 0 ;
14145 PLFLT *arg7 = (PLFLT *) 0 ;
14146 Matrix temp1 ;
14147 Matrix temp2 ;
14148 double val5 ;
14149 int ecode5 = 0 ;
14150 Matrix temp6 ;
14151 Matrix temp7 ;
14152 octave_value_list _out;
14153 octave_value_list *_outp=&_out;
14154 octave_value _outv;
14155
14156 if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
14157 SWIG_fail;
14158 }
14159 {
14160 if ( _n_dims( args(0) ) > 2 )
14161 {
14162 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14163 }
14164 temp1 = args(0).matrix_value();
14165 arg1 = &temp1( 0, 0 );
14166 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14167 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14168 }
14169 {
14170 if ( _n_dims( args(1) ) > 2 )
14171 {
14172 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14173 }
14174 if ( _dim( args(1), 0 ) != Xlen )
14175 {
14176 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14177 }
14178 if ( _dim( args(1), 1 ) != Ylen )
14179 {
14180 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14181 }
14182 temp2 = args(1).matrix_value();
14183 arg2 = &temp2( 0, 0 );
14184 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14185 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14186 }
14187 ecode5 = SWIG_AsVal_double(args(2), &val5);
14188 if (!SWIG_IsOK(ecode5)) {
14189 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
14190 }
14191 arg5 = static_cast< PLFLT >(val5);
14192 {
14193 if ( _n_dims( args(3) ) > 1 )
14194 {
14195 error( "argument must be a scalar or vector" ); SWIG_fail;
14196 }
14197 if ( _dim( args(3), 0 ) != Xlen )
14198 {
14199 error( "argument vectors must be same length" ); SWIG_fail;
14200 }
14201 temp6 = args(3).matrix_value();
14202 arg6 = &temp6( 0, 0 );
14203 }
14204 {
14205 if ( _n_dims( args(4) ) > 1 )
14206 {
14207 error( "argument must be a scalar or vector" ); SWIG_fail;
14208 }
14209 if ( _dim( args(4), 0 ) != Ylen )
14210 {
14211 error( "argument vectors must be same length" ); SWIG_fail;
14212 }
14213 temp7 = args(4).matrix_value();
14214 arg7 = &temp7( 0, 0 );
14215 }
14216 my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14217 _outv = octave_value();
14218 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14219 {
14220
14221 }
14222 {
14223
14224 }
14225 {
14226
14227 }
14228 {
14229
14230 }
14231 return _out;
14232 fail:
14233 {
14234
14235 }
14236 {
14237
14238 }
14239 {
14240
14241 }
14242 {
14243
14244 }
14245 return octave_value_list();
14246 }
14247
14248
14249 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
14250 PLFLT *arg1 = (PLFLT *) 0 ;
14251 PLFLT *arg2 = (PLFLT *) 0 ;
14252 PLINT arg3 ;
14253 PLINT arg4 ;
14254 PLFLT arg5 ;
14255 PLFLT *arg6 = (PLFLT *) 0 ;
14256 PLFLT *arg7 = (PLFLT *) 0 ;
14257 Matrix temp1 ;
14258 Matrix temp2 ;
14259 double val5 ;
14260 int ecode5 = 0 ;
14261 Matrix temp6 ;
14262 Matrix temp7 ;
14263 octave_value_list _out;
14264 octave_value_list *_outp=&_out;
14265 octave_value _outv;
14266
14267 if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
14268 SWIG_fail;
14269 }
14270 {
14271 if ( _n_dims( args(0) ) > 2 )
14272 {
14273 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14274 }
14275 temp1 = args(0).matrix_value();
14276 arg1 = &temp1( 0, 0 );
14277 Xlen = (PLINT) ( _dim( args(0), 0 ) );
14278 Ylen = (PLINT) ( _dim( args(0), 1 ) );
14279 }
14280 {
14281 if ( _n_dims( args(1) ) > 2 )
14282 {
14283 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14284 }
14285 if ( _dim( args(1), 0 ) != Xlen )
14286 {
14287 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
14288 }
14289 if ( _dim( args(1), 1 ) != Ylen )
14290 {
14291 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
14292 }
14293 temp2 = args(1).matrix_value();
14294 arg2 = &temp2( 0, 0 );
14295 arg3 = (PLINT) ( _dim( args(1), 0 ) );
14296 arg4 = (PLINT) ( _dim( args(1), 1 ) );
14297 }
14298 ecode5 = SWIG_AsVal_double(args(2), &val5);
14299 if (!SWIG_IsOK(ecode5)) {
14300 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
14301 }
14302 arg5 = static_cast< PLFLT >(val5);
14303 {
14304 if ( _n_dims( args(3) ) > 2 )
14305 {
14306 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14307 }
14308 temp6 = args(3).matrix_value();
14309 arg6 = &temp6( 0, 0 );
14310 Xlen = (PLINT) ( _dim( args(3), 0 ) );
14311 Ylen = (PLINT) ( _dim( args(3), 1 ) );
14312 }
14313 {
14314 if ( _n_dims( args(4) ) > 2 )
14315 {
14316 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14317 }
14318 temp7 = args(4).matrix_value();
14319 arg7 = &temp7( 0, 0 );
14320 Xlen = (PLINT) ( _dim( args(4), 0 ) );
14321 Ylen = (PLINT) ( _dim( args(4), 1 ) );
14322 }
14323 my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
14324 _outv = octave_value();
14325 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14326 {
14327
14328 }
14329 {
14330
14331 }
14332 {
14333
14334 }
14335 {
14336
14337 }
14338 return _out;
14339 fail:
14340 {
14341
14342 }
14343 {
14344
14345 }
14346 {
14347
14348 }
14349 {
14350
14351 }
14352 return octave_value_list();
14353 }
14354
14355
14356 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
14357 PLFLT *arg1 = (PLFLT *) 0 ;
14358 PLINT arg2 ;
14359 PLINT arg3 ;
14360 PLFLT arg4 ;
14361 PLFLT arg5 ;
14362 PLFLT arg6 ;
14363 PLFLT arg7 ;
14364 PLFLT arg8 ;
14365 PLFLT arg9 ;
14366 PLFLT arg10 ;
14367 PLFLT arg11 ;
14368 PLFLT arg12 ;
14369 PLFLT arg13 ;
14370 Matrix temp1 ;
14371 double val4 ;
14372 int ecode4 = 0 ;
14373 double val5 ;
14374 int ecode5 = 0 ;
14375 double val6 ;
14376 int ecode6 = 0 ;
14377 double val7 ;
14378 int ecode7 = 0 ;
14379 double val8 ;
14380 int ecode8 = 0 ;
14381 double val9 ;
14382 int ecode9 = 0 ;
14383 double val10 ;
14384 int ecode10 = 0 ;
14385 double val11 ;
14386 int ecode11 = 0 ;
14387 double val12 ;
14388 int ecode12 = 0 ;
14389 double val13 ;
14390 int ecode13 = 0 ;
14391 octave_value_list _out;
14392 octave_value_list *_outp=&_out;
14393 octave_value _outv;
14394
14395 if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
14396 SWIG_fail;
14397 }
14398 {
14399 if ( _n_dims( args(0) ) > 2 )
14400 {
14401 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14402 }
14403 temp1 = args(0).matrix_value();
14404 arg1 = &temp1( 0, 0 );
14405 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14406 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14407 }
14408 ecode4 = SWIG_AsVal_double(args(1), &val4);
14409 if (!SWIG_IsOK(ecode4)) {
14410 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
14411 }
14412 arg4 = static_cast< PLFLT >(val4);
14413 ecode5 = SWIG_AsVal_double(args(2), &val5);
14414 if (!SWIG_IsOK(ecode5)) {
14415 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
14416 }
14417 arg5 = static_cast< PLFLT >(val5);
14418 ecode6 = SWIG_AsVal_double(args(3), &val6);
14419 if (!SWIG_IsOK(ecode6)) {
14420 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
14421 }
14422 arg6 = static_cast< PLFLT >(val6);
14423 ecode7 = SWIG_AsVal_double(args(4), &val7);
14424 if (!SWIG_IsOK(ecode7)) {
14425 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
14426 }
14427 arg7 = static_cast< PLFLT >(val7);
14428 ecode8 = SWIG_AsVal_double(args(5), &val8);
14429 if (!SWIG_IsOK(ecode8)) {
14430 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
14431 }
14432 arg8 = static_cast< PLFLT >(val8);
14433 ecode9 = SWIG_AsVal_double(args(6), &val9);
14434 if (!SWIG_IsOK(ecode9)) {
14435 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
14436 }
14437 arg9 = static_cast< PLFLT >(val9);
14438 ecode10 = SWIG_AsVal_double(args(7), &val10);
14439 if (!SWIG_IsOK(ecode10)) {
14440 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
14441 }
14442 arg10 = static_cast< PLFLT >(val10);
14443 ecode11 = SWIG_AsVal_double(args(8), &val11);
14444 if (!SWIG_IsOK(ecode11)) {
14445 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
14446 }
14447 arg11 = static_cast< PLFLT >(val11);
14448 ecode12 = SWIG_AsVal_double(args(9), &val12);
14449 if (!SWIG_IsOK(ecode12)) {
14450 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
14451 }
14452 arg12 = static_cast< PLFLT >(val12);
14453 ecode13 = SWIG_AsVal_double(args(10), &val13);
14454 if (!SWIG_IsOK(ecode13)) {
14455 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
14456 }
14457 arg13 = static_cast< PLFLT >(val13);
14458 my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14459 _outv = octave_value();
14460 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14461 {
14462
14463 }
14464 return _out;
14465 fail:
14466 {
14467
14468 }
14469 return octave_value_list();
14470 }
14471
14472
14473 SWIG_DEFUN( plimagefr, _wrap_plimagefr, _wrap_plimagefr_texinfo ) {
14474 PLFLT *arg1 = (PLFLT *) 0 ;
14475 PLINT arg2 ;
14476 PLINT arg3 ;
14477 PLFLT arg4 ;
14478 PLFLT arg5 ;
14479 PLFLT arg6 ;
14480 PLFLT arg7 ;
14481 PLFLT arg8 ;
14482 PLFLT arg9 ;
14483 PLFLT arg10 ;
14484 PLFLT arg11 ;
14485 Matrix temp1 ;
14486 double val4 ;
14487 int ecode4 = 0 ;
14488 double val5 ;
14489 int ecode5 = 0 ;
14490 double val6 ;
14491 int ecode6 = 0 ;
14492 double val7 ;
14493 int ecode7 = 0 ;
14494 double val8 ;
14495 int ecode8 = 0 ;
14496 double val9 ;
14497 int ecode9 = 0 ;
14498 double val10 ;
14499 int ecode10 = 0 ;
14500 double val11 ;
14501 int ecode11 = 0 ;
14502 octave_value_list _out;
14503 octave_value_list *_outp=&_out;
14504 octave_value _outv;
14505
14506 if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
14507 SWIG_fail;
14508 }
14509 {
14510 if ( _n_dims( args(0) ) > 2 )
14511 {
14512 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14513 }
14514 temp1 = args(0).matrix_value();
14515 arg1 = &temp1( 0, 0 );
14516 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14517 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14518 }
14519 ecode4 = SWIG_AsVal_double(args(1), &val4);
14520 if (!SWIG_IsOK(ecode4)) {
14521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
14522 }
14523 arg4 = static_cast< PLFLT >(val4);
14524 ecode5 = SWIG_AsVal_double(args(2), &val5);
14525 if (!SWIG_IsOK(ecode5)) {
14526 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
14527 }
14528 arg5 = static_cast< PLFLT >(val5);
14529 ecode6 = SWIG_AsVal_double(args(3), &val6);
14530 if (!SWIG_IsOK(ecode6)) {
14531 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
14532 }
14533 arg6 = static_cast< PLFLT >(val6);
14534 ecode7 = SWIG_AsVal_double(args(4), &val7);
14535 if (!SWIG_IsOK(ecode7)) {
14536 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
14537 }
14538 arg7 = static_cast< PLFLT >(val7);
14539 ecode8 = SWIG_AsVal_double(args(5), &val8);
14540 if (!SWIG_IsOK(ecode8)) {
14541 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
14542 }
14543 arg8 = static_cast< PLFLT >(val8);
14544 ecode9 = SWIG_AsVal_double(args(6), &val9);
14545 if (!SWIG_IsOK(ecode9)) {
14546 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
14547 }
14548 arg9 = static_cast< PLFLT >(val9);
14549 ecode10 = SWIG_AsVal_double(args(7), &val10);
14550 if (!SWIG_IsOK(ecode10)) {
14551 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
14552 }
14553 arg10 = static_cast< PLFLT >(val10);
14554 ecode11 = SWIG_AsVal_double(args(8), &val11);
14555 if (!SWIG_IsOK(ecode11)) {
14556 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
14557 }
14558 arg11 = static_cast< PLFLT >(val11);
14559 my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
14560 _outv = octave_value();
14561 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14562 {
14563
14564 }
14565 return _out;
14566 fail:
14567 {
14568
14569 }
14570 return octave_value_list();
14571 }
14572
14573
14574 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
14575 PLFLT *arg1 = (PLFLT *) 0 ;
14576 PLINT arg2 ;
14577 PLINT arg3 ;
14578 PLFLT arg4 ;
14579 PLFLT arg5 ;
14580 PLFLT arg6 ;
14581 PLFLT arg7 ;
14582 PLFLT arg8 ;
14583 PLFLT arg9 ;
14584 PLFLT arg10 ;
14585 PLFLT arg11 ;
14586 PLFLT *arg12 = (PLFLT *) 0 ;
14587 Matrix temp1 ;
14588 double val4 ;
14589 int ecode4 = 0 ;
14590 double val5 ;
14591 int ecode5 = 0 ;
14592 double val6 ;
14593 int ecode6 = 0 ;
14594 double val7 ;
14595 int ecode7 = 0 ;
14596 double val8 ;
14597 int ecode8 = 0 ;
14598 double val9 ;
14599 int ecode9 = 0 ;
14600 double val10 ;
14601 int ecode10 = 0 ;
14602 double val11 ;
14603 int ecode11 = 0 ;
14604 Matrix temp12 ;
14605 octave_value_list _out;
14606 octave_value_list *_outp=&_out;
14607 octave_value _outv;
14608
14609 if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
14610 SWIG_fail;
14611 }
14612 {
14613 if ( _n_dims( args(0) ) > 2 )
14614 {
14615 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14616 }
14617 temp1 = args(0).matrix_value();
14618 arg1 = &temp1( 0, 0 );
14619 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14620 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14621 }
14622 ecode4 = SWIG_AsVal_double(args(1), &val4);
14623 if (!SWIG_IsOK(ecode4)) {
14624 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
14625 }
14626 arg4 = static_cast< PLFLT >(val4);
14627 ecode5 = SWIG_AsVal_double(args(2), &val5);
14628 if (!SWIG_IsOK(ecode5)) {
14629 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
14630 }
14631 arg5 = static_cast< PLFLT >(val5);
14632 ecode6 = SWIG_AsVal_double(args(3), &val6);
14633 if (!SWIG_IsOK(ecode6)) {
14634 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
14635 }
14636 arg6 = static_cast< PLFLT >(val6);
14637 ecode7 = SWIG_AsVal_double(args(4), &val7);
14638 if (!SWIG_IsOK(ecode7)) {
14639 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
14640 }
14641 arg7 = static_cast< PLFLT >(val7);
14642 ecode8 = SWIG_AsVal_double(args(5), &val8);
14643 if (!SWIG_IsOK(ecode8)) {
14644 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
14645 }
14646 arg8 = static_cast< PLFLT >(val8);
14647 ecode9 = SWIG_AsVal_double(args(6), &val9);
14648 if (!SWIG_IsOK(ecode9)) {
14649 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
14650 }
14651 arg9 = static_cast< PLFLT >(val9);
14652 ecode10 = SWIG_AsVal_double(args(7), &val10);
14653 if (!SWIG_IsOK(ecode10)) {
14654 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
14655 }
14656 arg10 = static_cast< PLFLT >(val10);
14657 ecode11 = SWIG_AsVal_double(args(8), &val11);
14658 if (!SWIG_IsOK(ecode11)) {
14659 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
14660 }
14661 arg11 = static_cast< PLFLT >(val11);
14662 {
14663 if ( _n_dims( args(9) ) > 1 )
14664 {
14665 error( "argument must be a scalar or vector" ); SWIG_fail;
14666 }
14667 if ( _dim( args(9), 0 ) != 6 )
14668 {
14669 error( "argument vectors must have length of 6" ); SWIG_fail;
14670 }
14671 temp12 = args(9).matrix_value();
14672 arg12 = &temp12( 0, 0 );
14673 }
14674 my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14675 _outv = octave_value();
14676 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14677 {
14678
14679 }
14680 {
14681
14682 }
14683 return _out;
14684 fail:
14685 {
14686
14687 }
14688 {
14689
14690 }
14691 return octave_value_list();
14692 }
14693
14694
14695 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
14696 PLFLT *arg1 = (PLFLT *) 0 ;
14697 PLINT arg2 ;
14698 PLINT arg3 ;
14699 PLFLT arg4 ;
14700 PLFLT arg5 ;
14701 PLFLT arg6 ;
14702 PLFLT arg7 ;
14703 PLFLT arg8 ;
14704 PLFLT arg9 ;
14705 PLFLT arg10 ;
14706 PLFLT arg11 ;
14707 PLFLT *arg12 = (PLFLT *) 0 ;
14708 PLFLT *arg13 = (PLFLT *) 0 ;
14709 Matrix temp1 ;
14710 double val4 ;
14711 int ecode4 = 0 ;
14712 double val5 ;
14713 int ecode5 = 0 ;
14714 double val6 ;
14715 int ecode6 = 0 ;
14716 double val7 ;
14717 int ecode7 = 0 ;
14718 double val8 ;
14719 int ecode8 = 0 ;
14720 double val9 ;
14721 int ecode9 = 0 ;
14722 double val10 ;
14723 int ecode10 = 0 ;
14724 double val11 ;
14725 int ecode11 = 0 ;
14726 Matrix temp12 ;
14727 Matrix temp13 ;
14728 octave_value_list _out;
14729 octave_value_list *_outp=&_out;
14730 octave_value _outv;
14731
14732 if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
14733 SWIG_fail;
14734 }
14735 {
14736 if ( _n_dims( args(0) ) > 2 )
14737 {
14738 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14739 }
14740 temp1 = args(0).matrix_value();
14741 arg1 = &temp1( 0, 0 );
14742 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14743 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14744 }
14745 ecode4 = SWIG_AsVal_double(args(1), &val4);
14746 if (!SWIG_IsOK(ecode4)) {
14747 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
14748 }
14749 arg4 = static_cast< PLFLT >(val4);
14750 ecode5 = SWIG_AsVal_double(args(2), &val5);
14751 if (!SWIG_IsOK(ecode5)) {
14752 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
14753 }
14754 arg5 = static_cast< PLFLT >(val5);
14755 ecode6 = SWIG_AsVal_double(args(3), &val6);
14756 if (!SWIG_IsOK(ecode6)) {
14757 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
14758 }
14759 arg6 = static_cast< PLFLT >(val6);
14760 ecode7 = SWIG_AsVal_double(args(4), &val7);
14761 if (!SWIG_IsOK(ecode7)) {
14762 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
14763 }
14764 arg7 = static_cast< PLFLT >(val7);
14765 ecode8 = SWIG_AsVal_double(args(5), &val8);
14766 if (!SWIG_IsOK(ecode8)) {
14767 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
14768 }
14769 arg8 = static_cast< PLFLT >(val8);
14770 ecode9 = SWIG_AsVal_double(args(6), &val9);
14771 if (!SWIG_IsOK(ecode9)) {
14772 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
14773 }
14774 arg9 = static_cast< PLFLT >(val9);
14775 ecode10 = SWIG_AsVal_double(args(7), &val10);
14776 if (!SWIG_IsOK(ecode10)) {
14777 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
14778 }
14779 arg10 = static_cast< PLFLT >(val10);
14780 ecode11 = SWIG_AsVal_double(args(8), &val11);
14781 if (!SWIG_IsOK(ecode11)) {
14782 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
14783 }
14784 arg11 = static_cast< PLFLT >(val11);
14785 {
14786 if ( _n_dims( args(9) ) > 1 )
14787 {
14788 error( "argument must be a scalar or vector" ); SWIG_fail;
14789 }
14790 if ( _dim( args(9), 0 ) != Xlen )
14791 {
14792 error( "argument vectors must be same length" ); SWIG_fail;
14793 }
14794 temp12 = args(9).matrix_value();
14795 arg12 = &temp12( 0, 0 );
14796 }
14797 {
14798 if ( _n_dims( args(10) ) > 1 )
14799 {
14800 error( "argument must be a scalar or vector" ); SWIG_fail;
14801 }
14802 if ( _dim( args(10), 0 ) != Ylen )
14803 {
14804 error( "argument vectors must be same length" ); SWIG_fail;
14805 }
14806 temp13 = args(10).matrix_value();
14807 arg13 = &temp13( 0, 0 );
14808 }
14809 my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
14810 _outv = octave_value();
14811 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14812 {
14813
14814 }
14815 {
14816
14817 }
14818 {
14819
14820 }
14821 return _out;
14822 fail:
14823 {
14824
14825 }
14826 {
14827
14828 }
14829 {
14830
14831 }
14832 return octave_value_list();
14833 }
14834
14835
14836 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
14837 PLFLT *arg1 = (PLFLT *) 0 ;
14838 PLINT arg2 ;
14839 PLINT arg3 ;
14840 PLFLT arg4 ;
14841 PLFLT arg5 ;
14842 PLFLT arg6 ;
14843 PLFLT arg7 ;
14844 PLFLT arg8 ;
14845 PLFLT arg9 ;
14846 PLFLT arg10 ;
14847 PLFLT arg11 ;
14848 PLFLT *arg12 = (PLFLT *) 0 ;
14849 PLFLT *arg13 = (PLFLT *) 0 ;
14850 Matrix temp1 ;
14851 double val4 ;
14852 int ecode4 = 0 ;
14853 double val5 ;
14854 int ecode5 = 0 ;
14855 double val6 ;
14856 int ecode6 = 0 ;
14857 double val7 ;
14858 int ecode7 = 0 ;
14859 double val8 ;
14860 int ecode8 = 0 ;
14861 double val9 ;
14862 int ecode9 = 0 ;
14863 double val10 ;
14864 int ecode10 = 0 ;
14865 double val11 ;
14866 int ecode11 = 0 ;
14867 Matrix temp12 ;
14868 Matrix temp13 ;
14869 octave_value_list _out;
14870 octave_value_list *_outp=&_out;
14871 octave_value _outv;
14872
14873 if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
14874 SWIG_fail;
14875 }
14876 {
14877 if ( _n_dims( args(0) ) > 2 )
14878 {
14879 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14880 }
14881 temp1 = args(0).matrix_value();
14882 arg1 = &temp1( 0, 0 );
14883 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
14884 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
14885 }
14886 ecode4 = SWIG_AsVal_double(args(1), &val4);
14887 if (!SWIG_IsOK(ecode4)) {
14888 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
14889 }
14890 arg4 = static_cast< PLFLT >(val4);
14891 ecode5 = SWIG_AsVal_double(args(2), &val5);
14892 if (!SWIG_IsOK(ecode5)) {
14893 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
14894 }
14895 arg5 = static_cast< PLFLT >(val5);
14896 ecode6 = SWIG_AsVal_double(args(3), &val6);
14897 if (!SWIG_IsOK(ecode6)) {
14898 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
14899 }
14900 arg6 = static_cast< PLFLT >(val6);
14901 ecode7 = SWIG_AsVal_double(args(4), &val7);
14902 if (!SWIG_IsOK(ecode7)) {
14903 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
14904 }
14905 arg7 = static_cast< PLFLT >(val7);
14906 ecode8 = SWIG_AsVal_double(args(5), &val8);
14907 if (!SWIG_IsOK(ecode8)) {
14908 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
14909 }
14910 arg8 = static_cast< PLFLT >(val8);
14911 ecode9 = SWIG_AsVal_double(args(6), &val9);
14912 if (!SWIG_IsOK(ecode9)) {
14913 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
14914 }
14915 arg9 = static_cast< PLFLT >(val9);
14916 ecode10 = SWIG_AsVal_double(args(7), &val10);
14917 if (!SWIG_IsOK(ecode10)) {
14918 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
14919 }
14920 arg10 = static_cast< PLFLT >(val10);
14921 ecode11 = SWIG_AsVal_double(args(8), &val11);
14922 if (!SWIG_IsOK(ecode11)) {
14923 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
14924 }
14925 arg11 = static_cast< PLFLT >(val11);
14926 {
14927 if ( _n_dims( args(9) ) > 2 )
14928 {
14929 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14930 }
14931 temp12 = args(9).matrix_value();
14932 arg12 = &temp12( 0, 0 );
14933 Xlen = (PLINT) ( _dim( args(9), 0 ) );
14934 Ylen = (PLINT) ( _dim( args(9), 1 ) );
14935 }
14936 {
14937 if ( _n_dims( args(10) ) > 2 )
14938 {
14939 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
14940 }
14941 temp13 = args(10).matrix_value();
14942 arg13 = &temp13( 0, 0 );
14943 Xlen = (PLINT) ( _dim( args(10), 0 ) );
14944 Ylen = (PLINT) ( _dim( args(10), 1 ) );
14945 }
14946 my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
14947 _outv = octave_value();
14948 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14949 {
14950
14951 }
14952 {
14953
14954 }
14955 {
14956
14957 }
14958 return _out;
14959 fail:
14960 {
14961
14962 }
14963 {
14964
14965 }
14966 {
14967
14968 }
14969 return octave_value_list();
14970 }
14971
14972
14973 SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, _wrap_plcolorbar_texinfo ) {
14974 PLFLT *arg1 = (PLFLT *) 0 ;
14975 PLFLT *arg2 = (PLFLT *) 0 ;
14976 PLINT arg3 ;
14977 PLINT arg4 ;
14978 PLFLT arg5 ;
14979 PLFLT arg6 ;
14980 PLFLT arg7 ;
14981 PLFLT arg8 ;
14982 PLINT arg9 ;
14983 PLINT arg10 ;
14984 PLINT arg11 ;
14985 PLFLT arg12 ;
14986 PLFLT arg13 ;
14987 PLINT arg14 ;
14988 PLFLT arg15 ;
14989 PLINT arg16 ;
14990 PLINT *arg17 = (PLINT *) 0 ;
14991 char **arg18 = (char **) 0 ;
14992 PLINT arg19 ;
14993 char **arg20 = (char **) 0 ;
14994 PLFLT *arg21 = (PLFLT *) 0 ;
14995 PLINT *arg22 = (PLINT *) 0 ;
14996 PLINT *arg23 = (PLINT *) 0 ;
14997 PLFLT *arg24 = (PLFLT *) 0 ;
14998 PLFLT temp1 ;
14999 int res1 = SWIG_TMPOBJ ;
15000 PLFLT temp2 ;
15001 int res2 = SWIG_TMPOBJ ;
15002 int val3 ;
15003 int ecode3 = 0 ;
15004 int val4 ;
15005 int ecode4 = 0 ;
15006 double val5 ;
15007 int ecode5 = 0 ;
15008 double val6 ;
15009 int ecode6 = 0 ;
15010 double val7 ;
15011 int ecode7 = 0 ;
15012 double val8 ;
15013 int ecode8 = 0 ;
15014 int val9 ;
15015 int ecode9 = 0 ;
15016 int val10 ;
15017 int ecode10 = 0 ;
15018 int val11 ;
15019 int ecode11 = 0 ;
15020 double val12 ;
15021 int ecode12 = 0 ;
15022 double val13 ;
15023 int ecode13 = 0 ;
15024 int val14 ;
15025 int ecode14 = 0 ;
15026 double val15 ;
15027 int ecode15 = 0 ;
15028 Matrix temp16 ;
15029 Matrix temp21 ;
15030 Matrix temp22 ;
15031 Matrix temp23 ;
15032 Matrix temp24 ;
15033 octave_value_list _out;
15034 octave_value_list *_outp=&_out;
15035 octave_value _outv;
15036
15037 arg1 = &temp1;
15038 arg2 = &temp2;
15039 if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
15040 SWIG_fail;
15041 }
15042 ecode3 = SWIG_AsVal_int(args(0), &val3);
15043 if (!SWIG_IsOK(ecode3)) {
15044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
15045 }
15046 arg3 = static_cast< PLINT >(val3);
15047 ecode4 = SWIG_AsVal_int(args(1), &val4);
15048 if (!SWIG_IsOK(ecode4)) {
15049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
15050 }
15051 arg4 = static_cast< PLINT >(val4);
15052 ecode5 = SWIG_AsVal_double(args(2), &val5);
15053 if (!SWIG_IsOK(ecode5)) {
15054 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
15055 }
15056 arg5 = static_cast< PLFLT >(val5);
15057 ecode6 = SWIG_AsVal_double(args(3), &val6);
15058 if (!SWIG_IsOK(ecode6)) {
15059 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
15060 }
15061 arg6 = static_cast< PLFLT >(val6);
15062 ecode7 = SWIG_AsVal_double(args(4), &val7);
15063 if (!SWIG_IsOK(ecode7)) {
15064 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
15065 }
15066 arg7 = static_cast< PLFLT >(val7);
15067 ecode8 = SWIG_AsVal_double(args(5), &val8);
15068 if (!SWIG_IsOK(ecode8)) {
15069 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
15070 }
15071 arg8 = static_cast< PLFLT >(val8);
15072 ecode9 = SWIG_AsVal_int(args(6), &val9);
15073 if (!SWIG_IsOK(ecode9)) {
15074 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
15075 }
15076 arg9 = static_cast< PLINT >(val9);
15077 ecode10 = SWIG_AsVal_int(args(7), &val10);
15078 if (!SWIG_IsOK(ecode10)) {
15079 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
15080 }
15081 arg10 = static_cast< PLINT >(val10);
15082 ecode11 = SWIG_AsVal_int(args(8), &val11);
15083 if (!SWIG_IsOK(ecode11)) {
15084 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
15085 }
15086 arg11 = static_cast< PLINT >(val11);
15087 ecode12 = SWIG_AsVal_double(args(9), &val12);
15088 if (!SWIG_IsOK(ecode12)) {
15089 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
15090 }
15091 arg12 = static_cast< PLFLT >(val12);
15092 ecode13 = SWIG_AsVal_double(args(10), &val13);
15093 if (!SWIG_IsOK(ecode13)) {
15094 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
15095 }
15096 arg13 = static_cast< PLFLT >(val13);
15097 ecode14 = SWIG_AsVal_int(args(11), &val14);
15098 if (!SWIG_IsOK(ecode14)) {
15099 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
15100 }
15101 arg14 = static_cast< PLINT >(val14);
15102 ecode15 = SWIG_AsVal_double(args(12), &val15);
15103 if (!SWIG_IsOK(ecode15)) {
15104 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
15105 }
15106 arg15 = static_cast< PLFLT >(val15);
15107 {
15108 if ( _n_dims( args(13) ) > 1 )
15109 {
15110 error( "argument must be a scalar or vector" ); SWIG_fail;
15111 }
15112 arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
15113 arg17 = new PLINT[Alen];
15114 temp16 = args(13).matrix_value();
15115 _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
15116 }
15117 {
15118 charMatrix temp_matrix;
15119 Cell temp_cell;
15120 char *tmp_cstring;
15121 std::string str;
15122 size_t max_length = 0, non_blank_length;
15123 int i, ifcell;
15124 if ( _n_dims( args(14) ) > 2 )
15125 {
15126 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15127 }
15128 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15129 if ( !args(14).isempty() )
15130 #else
15131 if ( !args(14).is_empty() )
15132 #endif
15133 {
15134 if ( _dim( args(14), 0 ) != Alen )
15135 {
15136 error( "first dimension must be same length as previous vector" ); SWIG_fail;
15137 }
15138 arg18 = new char*[Alen];
15139 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15140 ifcell = args(14).iscell();
15141 #else
15142 ifcell = args(14).is_cell();
15143 #endif
15144 if ( ifcell )
15145 {
15146 temp_cell = args(14).cell_value();
15147 }
15148 else
15149 {
15150 temp_matrix = args(14).char_matrix_value();
15151 // Allow one extra space for null termination.
15152 max_length = _dim( args(14), 1 ) + 1;
15153 }
15154
15155 for ( i = 0; i < Alen; i++ )
15156 {
15157 // Must copy string to "permanent" location because the string
15158 // location corresponding to tmp_cstring gets
15159 // overwritten for each iteration of loop.
15160 if ( ifcell )
15161 {
15162 if ( temp_cell.elem( i ).is_string() )
15163 {
15164 str = temp_cell.elem( i ).string_value();
15165 // leave room for null termination.
15166 max_length = str.size() + 1;
15167 tmp_cstring = (char *) str.c_str();
15168 }
15169 else
15170 {
15171 // Use null string if user attempts to pass a cell array
15172 // with a non-string element (likely an empty element
15173 // since that should be allowed by the PLplot interface
15174 // if that element is going to be unused).
15175 // leave room for null termination.
15176 max_length = 1;
15177 tmp_cstring = (char *) "";
15178 }
15179 }
15180 else
15181 {
15182 str = temp_matrix.row_as_string( i );
15183 tmp_cstring = (char *) str.c_str();
15184 }
15185 arg18[i] = new char[max_length];
15186 strncpy( arg18[i], tmp_cstring, max_length - 1 );
15187 arg18[i][max_length - 1] = '\0';
15188 // All the trailing blank crapola should not be needed for
15189 // string cell arrays.
15190 if ( !ifcell )
15191 {
15192 // remove trailing-blank padding that is used by the
15193 // charMatrix class to insure all strings in a given
15194 // charMatrix instance have the same length.
15195 // This transformation also removes legitimate trailing
15196 // blanks but there is nothing we can do about that
15197 // for the charMatrix class.
15198
15199 // Look for trailing nulls first (just in case, although that
15200 // shouldn't happen if charMatrix implemented as documented)
15201 // before looking for trailing blanks.
15202 non_blank_length = max_length - 2;
15203 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
15204 {
15205 non_blank_length--;
15206 }
15207 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
15208 {
15209 non_blank_length--;
15210 }
15211 arg18[i][non_blank_length + 1] = '\0';
15212 }
15213 }
15214 }
15215 else
15216 {
15217 arg18 = NULL;
15218 }
15219 }
15220 {
15221 charMatrix temp_matrix;
15222 Cell temp_cell;
15223 char *tmp_cstring;
15224 std::string str;
15225 size_t max_length = 0, non_blank_length;
15226 int i, ifcell;
15227 if ( _n_dims( args(15) ) > 2 )
15228 {
15229 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
15230 }
15231 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15232 if ( !args(15).isempty() )
15233 #else
15234 if ( !args(15).is_empty() )
15235 #endif
15236 {
15237 Alen = _dim( args(15), 0 );
15238 arg19 = Alen;
15239 arg20 = new char*[Alen];
15240 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
15241 ifcell = args(15).iscell();
15242 #else
15243 ifcell = args(15).is_cell();
15244 #endif
15245 if ( ifcell )
15246 {
15247 temp_cell = args(15).cell_value();
15248 }
15249 else
15250 {
15251 temp_matrix = args(15).char_matrix_value();
15252 // Allow one extra space for null termination.
15253 max_length = _dim( args(15), 1 ) + 1;
15254 }
15255
15256 for ( i = 0; i < Alen; i++ )
15257 {
15258 // Must copy string to "permanent" location because the string
15259 // location corresponding to tmp_cstring gets
15260 // overwritten for each iteration of loop.
15261 if ( ifcell )
15262 {
15263 if ( temp_cell.elem( i ).is_string() )
15264 {
15265 str = temp_cell.elem( i ).string_value();
15266 // leave room for null termination.
15267 max_length = str.size() + 1;
15268 tmp_cstring = (char *) str.c_str();
15269 }
15270 else
15271 {
15272 // Use null string if user attempts to pass a cell array
15273 // with a non-string element (likely an empty element
15274 // since that should be allowed by the PLplot interface
15275 // if that element is going to be unused).
15276 // leave room for null termination.
15277 max_length = 1;
15278 tmp_cstring = (char *) "";
15279 }
15280 }
15281 else
15282 {
15283 str = temp_matrix.row_as_string( i );
15284 tmp_cstring = (char *) str.c_str();
15285 }
15286 arg20[i] = new char[max_length];
15287 strncpy( arg20[i], tmp_cstring, max_length - 1 );
15288 arg20[i][max_length - 1] = '\0';
15289 // All the trailing blank crapola should not be needed for
15290 // string cell arrays.
15291 if ( !ifcell )
15292 {
15293 // remove trailing-blank padding that is used by the
15294 // charMatrix class to insure all strings in a given
15295 // charMatrix instance have the same length.
15296 // This transformation also removes legitimate trailing
15297 // blanks but there is nothing we can do about that
15298 // for the charMatrix class.
15299
15300 // Look for trailing nulls first (just in case, although that
15301 // shouldn't happen if charMatrix implemented as documented)
15302 // before looking for trailing blanks.
15303 non_blank_length = max_length - 2;
15304 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
15305 {
15306 non_blank_length--;
15307 }
15308 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
15309 {
15310 non_blank_length--;
15311 }
15312 arg20[i][non_blank_length + 1] = '\0';
15313 }
15314 }
15315 }
15316 else
15317 {
15318 arg19 = 0;
15319 arg20 = NULL;
15320 }
15321 }
15322 {
15323 if ( _n_dims( args(16) ) > 1 )
15324 {
15325 error( "argument must be a scalar or vector" ); SWIG_fail;
15326 }
15327 if ( _dim( args(16), 0 ) != Alen )
15328 {
15329 error( "argument vectors must be same length" ); SWIG_fail;
15330 }
15331 temp21 = args(16).matrix_value();
15332 arg21 = &temp21( 0, 0 );
15333 }
15334 {
15335 if ( _n_dims( args(17) ) > 1 )
15336 {
15337 error( "argument must be a scalar or vector" ); SWIG_fail;
15338 }
15339 if ( _dim( args(17), 0 ) != Alen )
15340 {
15341 error( "argument vectors must be same length" ); SWIG_fail;
15342 }
15343 temp22 = args(17).matrix_value();
15344 arg22 = new PLINT[Alen];
15345 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
15346 }
15347 {
15348 int i;
15349 if ( _n_dims( args(18) ) > 1 )
15350 {
15351 error( "argument must be a scalar or vector" ); SWIG_fail;
15352 }
15353 if ( _dim( args(18), 0 ) != Alen )
15354 {
15355 error( "argument vectors must be same length" ); SWIG_fail;
15356 }
15357 Xlen = Alen;
15358 temp23 = args(18).matrix_value();
15359 arg23 = new PLINT[Alen];
15360 _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
15361 Ylen = -1;
15362 for ( i = 0; i < Xlen; i++ )
15363 if ( arg23[i] > Ylen )
15364 Ylen = arg23[i];
15365 }
15366 {
15367 if ( _n_dims( args(19) ) > 2 )
15368 {
15369 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
15370 }
15371 if ( _dim( args(19), 0 ) != Xlen )
15372 {
15373 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
15374 }
15375 if ( _dim( args(19), 1 ) != Ylen )
15376 {
15377 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
15378 }
15379 temp24 = args(19).matrix_value();
15380 arg24 = &temp24( 0, 0 );
15381 }
15382 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);
15383 _outv = octave_value();
15384 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15385 if (SWIG_IsTmpObj(res1)) {
15386 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15387 } else {
15388 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15389 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15390 }
15391 if (SWIG_IsTmpObj(res2)) {
15392 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15393 } else {
15394 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15395 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15396 }
15397 {
15398 delete [] arg17;
15399 }
15400 {
15401 int i;
15402 if ( arg18 != NULL )
15403 {
15404 for ( i = 0; i < Alen; i++ )
15405 {
15406 delete[] arg18[i];
15407 }
15408 delete[] arg18;
15409 }
15410 }
15411 {
15412 int i;
15413 if ( arg20 != NULL )
15414 {
15415 for ( i = 0; i < Alen; i++ )
15416 {
15417 delete[] arg20[i];
15418 }
15419 delete[] arg20;
15420 }
15421 }
15422 {
15423
15424 }
15425 {
15426 delete [] arg22;
15427 }
15428 {
15429 delete [] arg23;
15430 }
15431 {
15432
15433 }
15434 return _out;
15435 fail:
15436 {
15437 delete [] arg17;
15438 }
15439 {
15440 int i;
15441 if ( arg18 != NULL )
15442 {
15443 for ( i = 0; i < Alen; i++ )
15444 {
15445 delete[] arg18[i];
15446 }
15447 delete[] arg18;
15448 }
15449 }
15450 {
15451 int i;
15452 if ( arg20 != NULL )
15453 {
15454 for ( i = 0; i < Alen; i++ )
15455 {
15456 delete[] arg20[i];
15457 }
15458 delete[] arg20;
15459 }
15460 }
15461 {
15462
15463 }
15464 {
15465 delete [] arg22;
15466 }
15467 {
15468 delete [] arg23;
15469 }
15470 {
15471
15472 }
15473 return octave_value_list();
15474 }
15475
15476
15477 SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
15478 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15479 int arg2 ;
15480 void *argp1 = 0 ;
15481 int res1 = 0 ;
15482 int val2 ;
15483 int ecode2 = 0 ;
15484 octave_value_list _out;
15485 octave_value_list *_outp=&_out;
15486 octave_value _outv;
15487
15488 if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
15489 SWIG_fail;
15490 }
15491 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15492 if (!SWIG_IsOK(res1)) {
15493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15494 }
15495 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15496 ecode2 = SWIG_AsVal_int(args(1), &val2);
15497 if (!SWIG_IsOK(ecode2)) {
15498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
15499 }
15500 arg2 = static_cast< int >(val2);
15501 if (arg1) (arg1)->type = arg2;
15502 _outv = octave_value();
15503 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15504 return _out;
15505 fail:
15506 return octave_value_list();
15507 }
15508
15509
15510 SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
15511 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15512 void *argp1 = 0 ;
15513 int res1 = 0 ;
15514 octave_value_list _out;
15515 octave_value_list *_outp=&_out;
15516 octave_value _outv;
15517 int result;
15518
15519 if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
15520 SWIG_fail;
15521 }
15522 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15523 if (!SWIG_IsOK(res1)) {
15524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15525 }
15526 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15527 result = (int) ((arg1)->type);
15528 _outv = SWIG_From_int(static_cast< int >(result));
15529 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15530 return _out;
15531 fail:
15532 return octave_value_list();
15533 }
15534
15535
15536 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
15537 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15538 unsigned int arg2 ;
15539 void *argp1 = 0 ;
15540 int res1 = 0 ;
15541 unsigned int val2 ;
15542 int ecode2 = 0 ;
15543 octave_value_list _out;
15544 octave_value_list *_outp=&_out;
15545 octave_value _outv;
15546
15547 if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
15548 SWIG_fail;
15549 }
15550 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15551 if (!SWIG_IsOK(res1)) {
15552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15553 }
15554 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15555 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15556 if (!SWIG_IsOK(ecode2)) {
15557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
15558 }
15559 arg2 = static_cast< unsigned int >(val2);
15560 if (arg1) (arg1)->state = arg2;
15561 _outv = octave_value();
15562 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15563 return _out;
15564 fail:
15565 return octave_value_list();
15566 }
15567
15568
15569 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
15570 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15571 void *argp1 = 0 ;
15572 int res1 = 0 ;
15573 octave_value_list _out;
15574 octave_value_list *_outp=&_out;
15575 octave_value _outv;
15576 unsigned int result;
15577
15578 if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
15579 SWIG_fail;
15580 }
15581 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15582 if (!SWIG_IsOK(res1)) {
15583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15584 }
15585 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15586 result = (unsigned int) ((arg1)->state);
15587 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15588 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15589 return _out;
15590 fail:
15591 return octave_value_list();
15592 }
15593
15594
15595 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
15596 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15597 unsigned int arg2 ;
15598 void *argp1 = 0 ;
15599 int res1 = 0 ;
15600 unsigned int val2 ;
15601 int ecode2 = 0 ;
15602 octave_value_list _out;
15603 octave_value_list *_outp=&_out;
15604 octave_value _outv;
15605
15606 if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
15607 SWIG_fail;
15608 }
15609 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15610 if (!SWIG_IsOK(res1)) {
15611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15612 }
15613 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15614 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15615 if (!SWIG_IsOK(ecode2)) {
15616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
15617 }
15618 arg2 = static_cast< unsigned int >(val2);
15619 if (arg1) (arg1)->keysym = arg2;
15620 _outv = octave_value();
15621 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15622 return _out;
15623 fail:
15624 return octave_value_list();
15625 }
15626
15627
15628 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
15629 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15630 void *argp1 = 0 ;
15631 int res1 = 0 ;
15632 octave_value_list _out;
15633 octave_value_list *_outp=&_out;
15634 octave_value _outv;
15635 unsigned int result;
15636
15637 if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
15638 SWIG_fail;
15639 }
15640 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15641 if (!SWIG_IsOK(res1)) {
15642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15643 }
15644 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15645 result = (unsigned int) ((arg1)->keysym);
15646 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15647 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15648 return _out;
15649 fail:
15650 return octave_value_list();
15651 }
15652
15653
15654 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
15655 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15656 unsigned int arg2 ;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 unsigned int val2 ;
15660 int ecode2 = 0 ;
15661 octave_value_list _out;
15662 octave_value_list *_outp=&_out;
15663 octave_value _outv;
15664
15665 if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
15666 SWIG_fail;
15667 }
15668 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15669 if (!SWIG_IsOK(res1)) {
15670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15671 }
15672 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15673 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
15674 if (!SWIG_IsOK(ecode2)) {
15675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
15676 }
15677 arg2 = static_cast< unsigned int >(val2);
15678 if (arg1) (arg1)->button = arg2;
15679 _outv = octave_value();
15680 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15681 return _out;
15682 fail:
15683 return octave_value_list();
15684 }
15685
15686
15687 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
15688 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15689 void *argp1 = 0 ;
15690 int res1 = 0 ;
15691 octave_value_list _out;
15692 octave_value_list *_outp=&_out;
15693 octave_value _outv;
15694 unsigned int result;
15695
15696 if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
15697 SWIG_fail;
15698 }
15699 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15700 if (!SWIG_IsOK(res1)) {
15701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15702 }
15703 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15704 result = (unsigned int) ((arg1)->button);
15705 _outv = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
15706 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15707 return _out;
15708 fail:
15709 return octave_value_list();
15710 }
15711
15712
15713 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
15714 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15715 PLINT arg2 ;
15716 void *argp1 = 0 ;
15717 int res1 = 0 ;
15718 int val2 ;
15719 int ecode2 = 0 ;
15720 octave_value_list _out;
15721 octave_value_list *_outp=&_out;
15722 octave_value _outv;
15723
15724 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
15725 SWIG_fail;
15726 }
15727 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15728 if (!SWIG_IsOK(res1)) {
15729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15730 }
15731 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15732 ecode2 = SWIG_AsVal_int(args(1), &val2);
15733 if (!SWIG_IsOK(ecode2)) {
15734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
15735 }
15736 arg2 = static_cast< PLINT >(val2);
15737 if (arg1) (arg1)->subwindow = arg2;
15738 _outv = octave_value();
15739 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15740 return _out;
15741 fail:
15742 return octave_value_list();
15743 }
15744
15745
15746 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
15747 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15748 void *argp1 = 0 ;
15749 int res1 = 0 ;
15750 octave_value_list _out;
15751 octave_value_list *_outp=&_out;
15752 octave_value _outv;
15753 PLINT result;
15754
15755 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
15756 SWIG_fail;
15757 }
15758 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15759 if (!SWIG_IsOK(res1)) {
15760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15761 }
15762 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15763 result = (PLINT) ((arg1)->subwindow);
15764 _outv = SWIG_From_int(static_cast< int >(result));
15765 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15766 return _out;
15767 fail:
15768 return octave_value_list();
15769 }
15770
15771
15772 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
15773 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15774 char *arg2 ;
15775 void *argp1 = 0 ;
15776 int res1 = 0 ;
15777 char temp2[16] ;
15778 int res2 ;
15779 octave_value_list _out;
15780 octave_value_list *_outp=&_out;
15781 octave_value _outv;
15782
15783 if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
15784 SWIG_fail;
15785 }
15786 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15787 if (!SWIG_IsOK(res1)) {
15788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15789 }
15790 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15791 res2 = SWIG_AsCharArray(args(1), temp2, 16);
15792 if (!SWIG_IsOK(res2)) {
15793 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
15794 }
15795 arg2 = reinterpret_cast< char * >(temp2);
15796 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
15797 else memset(arg1->string,0,16*sizeof(char));
15798 _outv = octave_value();
15799 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15800 return _out;
15801 fail:
15802 return octave_value_list();
15803 }
15804
15805
15806 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
15807 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15808 void *argp1 = 0 ;
15809 int res1 = 0 ;
15810 octave_value_list _out;
15811 octave_value_list *_outp=&_out;
15812 octave_value _outv;
15813 char *result = 0 ;
15814
15815 if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
15816 SWIG_fail;
15817 }
15818 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15819 if (!SWIG_IsOK(res1)) {
15820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15821 }
15822 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15823 result = (char *)(char *) ((arg1)->string);
15824 {
15825 size_t size = SWIG_strnlen(result, 16);
15826
15827
15828
15829 _outv = SWIG_FromCharPtrAndSize(result, size);
15830 }
15831 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15832 return _out;
15833 fail:
15834 return octave_value_list();
15835 }
15836
15837
15838 SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
15839 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15840 int arg2 ;
15841 void *argp1 = 0 ;
15842 int res1 = 0 ;
15843 int val2 ;
15844 int ecode2 = 0 ;
15845 octave_value_list _out;
15846 octave_value_list *_outp=&_out;
15847 octave_value _outv;
15848
15849 if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
15850 SWIG_fail;
15851 }
15852 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15853 if (!SWIG_IsOK(res1)) {
15854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15855 }
15856 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15857 ecode2 = SWIG_AsVal_int(args(1), &val2);
15858 if (!SWIG_IsOK(ecode2)) {
15859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
15860 }
15861 arg2 = static_cast< int >(val2);
15862 if (arg1) (arg1)->pX = arg2;
15863 _outv = octave_value();
15864 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15865 return _out;
15866 fail:
15867 return octave_value_list();
15868 }
15869
15870
15871 SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
15872 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15873 void *argp1 = 0 ;
15874 int res1 = 0 ;
15875 octave_value_list _out;
15876 octave_value_list *_outp=&_out;
15877 octave_value _outv;
15878 int result;
15879
15880 if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
15881 SWIG_fail;
15882 }
15883 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15884 if (!SWIG_IsOK(res1)) {
15885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15886 }
15887 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15888 result = (int) ((arg1)->pX);
15889 _outv = SWIG_From_int(static_cast< int >(result));
15890 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15891 return _out;
15892 fail:
15893 return octave_value_list();
15894 }
15895
15896
15897 SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
15898 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15899 int arg2 ;
15900 void *argp1 = 0 ;
15901 int res1 = 0 ;
15902 int val2 ;
15903 int ecode2 = 0 ;
15904 octave_value_list _out;
15905 octave_value_list *_outp=&_out;
15906 octave_value _outv;
15907
15908 if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
15909 SWIG_fail;
15910 }
15911 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15912 if (!SWIG_IsOK(res1)) {
15913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15914 }
15915 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15916 ecode2 = SWIG_AsVal_int(args(1), &val2);
15917 if (!SWIG_IsOK(ecode2)) {
15918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
15919 }
15920 arg2 = static_cast< int >(val2);
15921 if (arg1) (arg1)->pY = arg2;
15922 _outv = octave_value();
15923 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15924 return _out;
15925 fail:
15926 return octave_value_list();
15927 }
15928
15929
15930 SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
15931 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15932 void *argp1 = 0 ;
15933 int res1 = 0 ;
15934 octave_value_list _out;
15935 octave_value_list *_outp=&_out;
15936 octave_value _outv;
15937 int result;
15938
15939 if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
15940 SWIG_fail;
15941 }
15942 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15943 if (!SWIG_IsOK(res1)) {
15944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15945 }
15946 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15947 result = (int) ((arg1)->pY);
15948 _outv = SWIG_From_int(static_cast< int >(result));
15949 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15950 return _out;
15951 fail:
15952 return octave_value_list();
15953 }
15954
15955
15956 SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
15957 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15958 PLFLT arg2 ;
15959 void *argp1 = 0 ;
15960 int res1 = 0 ;
15961 double val2 ;
15962 int ecode2 = 0 ;
15963 octave_value_list _out;
15964 octave_value_list *_outp=&_out;
15965 octave_value _outv;
15966
15967 if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
15968 SWIG_fail;
15969 }
15970 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
15971 if (!SWIG_IsOK(res1)) {
15972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
15973 }
15974 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
15975 ecode2 = SWIG_AsVal_double(args(1), &val2);
15976 if (!SWIG_IsOK(ecode2)) {
15977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
15978 }
15979 arg2 = static_cast< PLFLT >(val2);
15980 if (arg1) (arg1)->dX = arg2;
15981 _outv = octave_value();
15982 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15983 return _out;
15984 fail:
15985 return octave_value_list();
15986 }
15987
15988
15989 SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
15990 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
15991 void *argp1 = 0 ;
15992 int res1 = 0 ;
15993 octave_value_list _out;
15994 octave_value_list *_outp=&_out;
15995 octave_value _outv;
15996 PLFLT result;
15997
15998 if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
15999 SWIG_fail;
16000 }
16001 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16002 if (!SWIG_IsOK(res1)) {
16003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16004 }
16005 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16006 result = (PLFLT) ((arg1)->dX);
16007 _outv = SWIG_From_double(static_cast< double >(result));
16008 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16009 return _out;
16010 fail:
16011 return octave_value_list();
16012 }
16013
16014
16015 SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
16016 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16017 PLFLT arg2 ;
16018 void *argp1 = 0 ;
16019 int res1 = 0 ;
16020 double val2 ;
16021 int ecode2 = 0 ;
16022 octave_value_list _out;
16023 octave_value_list *_outp=&_out;
16024 octave_value _outv;
16025
16026 if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
16027 SWIG_fail;
16028 }
16029 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16030 if (!SWIG_IsOK(res1)) {
16031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16032 }
16033 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16034 ecode2 = SWIG_AsVal_double(args(1), &val2);
16035 if (!SWIG_IsOK(ecode2)) {
16036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
16037 }
16038 arg2 = static_cast< PLFLT >(val2);
16039 if (arg1) (arg1)->dY = arg2;
16040 _outv = octave_value();
16041 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16042 return _out;
16043 fail:
16044 return octave_value_list();
16045 }
16046
16047
16048 SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
16049 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16050 void *argp1 = 0 ;
16051 int res1 = 0 ;
16052 octave_value_list _out;
16053 octave_value_list *_outp=&_out;
16054 octave_value _outv;
16055 PLFLT result;
16056
16057 if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
16058 SWIG_fail;
16059 }
16060 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16061 if (!SWIG_IsOK(res1)) {
16062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16063 }
16064 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16065 result = (PLFLT) ((arg1)->dY);
16066 _outv = SWIG_From_double(static_cast< double >(result));
16067 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16068 return _out;
16069 fail:
16070 return octave_value_list();
16071 }
16072
16073
16074 SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
16075 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16076 PLFLT arg2 ;
16077 void *argp1 = 0 ;
16078 int res1 = 0 ;
16079 double val2 ;
16080 int ecode2 = 0 ;
16081 octave_value_list _out;
16082 octave_value_list *_outp=&_out;
16083 octave_value _outv;
16084
16085 if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
16086 SWIG_fail;
16087 }
16088 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16089 if (!SWIG_IsOK(res1)) {
16090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16091 }
16092 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16093 ecode2 = SWIG_AsVal_double(args(1), &val2);
16094 if (!SWIG_IsOK(ecode2)) {
16095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
16096 }
16097 arg2 = static_cast< PLFLT >(val2);
16098 if (arg1) (arg1)->wX = arg2;
16099 _outv = octave_value();
16100 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16101 return _out;
16102 fail:
16103 return octave_value_list();
16104 }
16105
16106
16107 SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
16108 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16109 void *argp1 = 0 ;
16110 int res1 = 0 ;
16111 octave_value_list _out;
16112 octave_value_list *_outp=&_out;
16113 octave_value _outv;
16114 PLFLT result;
16115
16116 if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
16117 SWIG_fail;
16118 }
16119 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16120 if (!SWIG_IsOK(res1)) {
16121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16122 }
16123 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16124 result = (PLFLT) ((arg1)->wX);
16125 _outv = SWIG_From_double(static_cast< double >(result));
16126 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16127 return _out;
16128 fail:
16129 return octave_value_list();
16130 }
16131
16132
16133 SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
16134 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16135 PLFLT arg2 ;
16136 void *argp1 = 0 ;
16137 int res1 = 0 ;
16138 double val2 ;
16139 int ecode2 = 0 ;
16140 octave_value_list _out;
16141 octave_value_list *_outp=&_out;
16142 octave_value _outv;
16143
16144 if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
16145 SWIG_fail;
16146 }
16147 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16148 if (!SWIG_IsOK(res1)) {
16149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16150 }
16151 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16152 ecode2 = SWIG_AsVal_double(args(1), &val2);
16153 if (!SWIG_IsOK(ecode2)) {
16154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
16155 }
16156 arg2 = static_cast< PLFLT >(val2);
16157 if (arg1) (arg1)->wY = arg2;
16158 _outv = octave_value();
16159 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16160 return _out;
16161 fail:
16162 return octave_value_list();
16163 }
16164
16165
16166 SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
16167 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16168 void *argp1 = 0 ;
16169 int res1 = 0 ;
16170 octave_value_list _out;
16171 octave_value_list *_outp=&_out;
16172 octave_value _outv;
16173 PLFLT result;
16174
16175 if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
16176 SWIG_fail;
16177 }
16178 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
16179 if (!SWIG_IsOK(res1)) {
16180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16181 }
16182 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16183 result = (PLFLT) ((arg1)->wY);
16184 _outv = SWIG_From_double(static_cast< double >(result));
16185 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16186 return _out;
16187 fail:
16188 return octave_value_list();
16189 }
16190
16191
16192 SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
16193 octave_value_list _out;
16194 octave_value_list *_outp=&_out;
16195 octave_value _outv;
16196 PLGraphicsIn *result = 0 ;
16197
16198 if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
16199 SWIG_fail;
16200 }
16201 result = (PLGraphicsIn *)new PLGraphicsIn();
16202 _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PLGraphicsIn, 1 | 0 );
16203 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16204 return _out;
16205 fail:
16206 return octave_value_list();
16207 }
16208
16209
16210 SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
16211 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
16212 void *argp1 = 0 ;
16213 int res1 = 0 ;
16214 octave_value_list _out;
16215 octave_value_list *_outp=&_out;
16216 octave_value _outv;
16217
16218 if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
16219 SWIG_fail;
16220 }
16221 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
16222 if (!SWIG_IsOK(res1)) {
16223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
16224 }
16225 arg1 = reinterpret_cast< PLGraphicsIn * >(argp1);
16226 delete arg1;
16227 _outv = octave_value();
16228 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16229 return _out;
16230 fail:
16231 return octave_value_list();
16232 }
16233
16234
16235 static swig_octave_member swig_PLGraphicsIn_members[] = {
16236 {"type",0,_wrap_PLGraphicsIn_type_get,_wrap_PLGraphicsIn_type_set,0,0},
16237 {"state",0,_wrap_PLGraphicsIn_state_get,_wrap_PLGraphicsIn_state_set,0,0},
16238 {"keysym",0,_wrap_PLGraphicsIn_keysym_get,_wrap_PLGraphicsIn_keysym_set,0,0},
16239 {"button",0,_wrap_PLGraphicsIn_button_get,_wrap_PLGraphicsIn_button_set,0,0},
16240 {"subwindow",0,_wrap_PLGraphicsIn_subwindow_get,_wrap_PLGraphicsIn_subwindow_set,0,0},
16241 {"string",0,_wrap_PLGraphicsIn_string_get,_wrap_PLGraphicsIn_string_set,0,0},
16242 {"pX",0,_wrap_PLGraphicsIn_pX_get,_wrap_PLGraphicsIn_pX_set,0,0},
16243 {"pY",0,_wrap_PLGraphicsIn_pY_get,_wrap_PLGraphicsIn_pY_set,0,0},
16244 {"dX",0,_wrap_PLGraphicsIn_dX_get,_wrap_PLGraphicsIn_dX_set,0,0},
16245 {"dY",0,_wrap_PLGraphicsIn_dY_get,_wrap_PLGraphicsIn_dY_set,0,0},
16246 {"wX",0,_wrap_PLGraphicsIn_wX_get,_wrap_PLGraphicsIn_wX_set,0,0},
16247 {"wY",0,_wrap_PLGraphicsIn_wY_get,_wrap_PLGraphicsIn_wY_set,0,0},
16248 {0,0,0,0,0,0}
16249 };
16250 static const char *swig_PLGraphicsIn_base_names[] = {0};
16251 static const swig_type_info *swig_PLGraphicsIn_base[] = {0};
16252 static swig_octave_class _wrap_class_PLGraphicsIn = {"PLGraphicsIn", &SWIGTYPE_p_PLGraphicsIn,0,_wrap_new_PLGraphicsIn,0,_wrap_delete_PLGraphicsIn,swig_PLGraphicsIn_members,swig_PLGraphicsIn_base_names,swig_PLGraphicsIn_base };
16253
16254 SWIG_DEFUN( pl_setcontlabelformat, _wrap_pl_setcontlabelformat, _wrap_pl_setcontlabelformat_texinfo ) {
16255 PLINT arg1 ;
16256 PLINT arg2 ;
16257 int val1 ;
16258 int ecode1 = 0 ;
16259 int val2 ;
16260 int ecode2 = 0 ;
16261 octave_value_list _out;
16262 octave_value_list *_outp=&_out;
16263 octave_value _outv;
16264
16265 if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
16266 SWIG_fail;
16267 }
16268 ecode1 = SWIG_AsVal_int(args(0), &val1);
16269 if (!SWIG_IsOK(ecode1)) {
16270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
16271 }
16272 arg1 = static_cast< PLINT >(val1);
16273 ecode2 = SWIG_AsVal_int(args(1), &val2);
16274 if (!SWIG_IsOK(ecode2)) {
16275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
16276 }
16277 arg2 = static_cast< PLINT >(val2);
16278 pl_setcontlabelformat(arg1,arg2);
16279 _outv = octave_value();
16280 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16281 return _out;
16282 fail:
16283 return octave_value_list();
16284 }
16285
16286
16287 SWIG_DEFUN( pl_setcontlabelparam, _wrap_pl_setcontlabelparam, _wrap_pl_setcontlabelparam_texinfo ) {
16288 PLFLT arg1 ;
16289 PLFLT arg2 ;
16290 PLFLT arg3 ;
16291 PLINT arg4 ;
16292 double val1 ;
16293 int ecode1 = 0 ;
16294 double val2 ;
16295 int ecode2 = 0 ;
16296 double val3 ;
16297 int ecode3 = 0 ;
16298 int val4 ;
16299 int ecode4 = 0 ;
16300 octave_value_list _out;
16301 octave_value_list *_outp=&_out;
16302 octave_value _outv;
16303
16304 if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
16305 SWIG_fail;
16306 }
16307 ecode1 = SWIG_AsVal_double(args(0), &val1);
16308 if (!SWIG_IsOK(ecode1)) {
16309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
16310 }
16311 arg1 = static_cast< PLFLT >(val1);
16312 ecode2 = SWIG_AsVal_double(args(1), &val2);
16313 if (!SWIG_IsOK(ecode2)) {
16314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
16315 }
16316 arg2 = static_cast< PLFLT >(val2);
16317 ecode3 = SWIG_AsVal_double(args(2), &val3);
16318 if (!SWIG_IsOK(ecode3)) {
16319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
16320 }
16321 arg3 = static_cast< PLFLT >(val3);
16322 ecode4 = SWIG_AsVal_int(args(3), &val4);
16323 if (!SWIG_IsOK(ecode4)) {
16324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
16325 }
16326 arg4 = static_cast< PLINT >(val4);
16327 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
16328 _outv = octave_value();
16329 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16330 return _out;
16331 fail:
16332 return octave_value_list();
16333 }
16334
16335
16336 SWIG_DEFUN( pladv, _wrap_pladv, _wrap_pladv_texinfo ) {
16337 PLINT arg1 ;
16338 int val1 ;
16339 int ecode1 = 0 ;
16340 octave_value_list _out;
16341 octave_value_list *_outp=&_out;
16342 octave_value _outv;
16343
16344 if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
16345 SWIG_fail;
16346 }
16347 ecode1 = SWIG_AsVal_int(args(0), &val1);
16348 if (!SWIG_IsOK(ecode1)) {
16349 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
16350 }
16351 arg1 = static_cast< PLINT >(val1);
16352 pladv(arg1);
16353 _outv = octave_value();
16354 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16355 return _out;
16356 fail:
16357 return octave_value_list();
16358 }
16359
16360
16361 SWIG_DEFUN( plarc, _wrap_plarc, _wrap_plarc_texinfo ) {
16362 PLFLT arg1 ;
16363 PLFLT arg2 ;
16364 PLFLT arg3 ;
16365 PLFLT arg4 ;
16366 PLFLT arg5 ;
16367 PLFLT arg6 ;
16368 PLFLT arg7 ;
16369 PLBOOL arg8 ;
16370 double val1 ;
16371 int ecode1 = 0 ;
16372 double val2 ;
16373 int ecode2 = 0 ;
16374 double val3 ;
16375 int ecode3 = 0 ;
16376 double val4 ;
16377 int ecode4 = 0 ;
16378 double val5 ;
16379 int ecode5 = 0 ;
16380 double val6 ;
16381 int ecode6 = 0 ;
16382 double val7 ;
16383 int ecode7 = 0 ;
16384 int val8 ;
16385 int ecode8 = 0 ;
16386 octave_value_list _out;
16387 octave_value_list *_outp=&_out;
16388 octave_value _outv;
16389
16390 if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
16391 SWIG_fail;
16392 }
16393 ecode1 = SWIG_AsVal_double(args(0), &val1);
16394 if (!SWIG_IsOK(ecode1)) {
16395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
16396 }
16397 arg1 = static_cast< PLFLT >(val1);
16398 ecode2 = SWIG_AsVal_double(args(1), &val2);
16399 if (!SWIG_IsOK(ecode2)) {
16400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
16401 }
16402 arg2 = static_cast< PLFLT >(val2);
16403 ecode3 = SWIG_AsVal_double(args(2), &val3);
16404 if (!SWIG_IsOK(ecode3)) {
16405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
16406 }
16407 arg3 = static_cast< PLFLT >(val3);
16408 ecode4 = SWIG_AsVal_double(args(3), &val4);
16409 if (!SWIG_IsOK(ecode4)) {
16410 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
16411 }
16412 arg4 = static_cast< PLFLT >(val4);
16413 ecode5 = SWIG_AsVal_double(args(4), &val5);
16414 if (!SWIG_IsOK(ecode5)) {
16415 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
16416 }
16417 arg5 = static_cast< PLFLT >(val5);
16418 ecode6 = SWIG_AsVal_double(args(5), &val6);
16419 if (!SWIG_IsOK(ecode6)) {
16420 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
16421 }
16422 arg6 = static_cast< PLFLT >(val6);
16423 ecode7 = SWIG_AsVal_double(args(6), &val7);
16424 if (!SWIG_IsOK(ecode7)) {
16425 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
16426 }
16427 arg7 = static_cast< PLFLT >(val7);
16428 ecode8 = SWIG_AsVal_int(args(7), &val8);
16429 if (!SWIG_IsOK(ecode8)) {
16430 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
16431 }
16432 arg8 = static_cast< PLBOOL >(val8);
16433 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
16434 _outv = octave_value();
16435 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16436 return _out;
16437 fail:
16438 return octave_value_list();
16439 }
16440
16441
16442 SWIG_DEFUN( plaxes, _wrap_plaxes, _wrap_plaxes_texinfo ) {
16443 PLFLT arg1 ;
16444 PLFLT arg2 ;
16445 char *arg3 = (char *) 0 ;
16446 PLFLT arg4 ;
16447 PLINT arg5 ;
16448 char *arg6 = (char *) 0 ;
16449 PLFLT arg7 ;
16450 PLINT arg8 ;
16451 double val1 ;
16452 int ecode1 = 0 ;
16453 double val2 ;
16454 int ecode2 = 0 ;
16455 int res3 ;
16456 char *buf3 = 0 ;
16457 int alloc3 = 0 ;
16458 double val4 ;
16459 int ecode4 = 0 ;
16460 int val5 ;
16461 int ecode5 = 0 ;
16462 int res6 ;
16463 char *buf6 = 0 ;
16464 int alloc6 = 0 ;
16465 double val7 ;
16466 int ecode7 = 0 ;
16467 int val8 ;
16468 int ecode8 = 0 ;
16469 octave_value_list _out;
16470 octave_value_list *_outp=&_out;
16471 octave_value _outv;
16472
16473 if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
16474 SWIG_fail;
16475 }
16476 ecode1 = SWIG_AsVal_double(args(0), &val1);
16477 if (!SWIG_IsOK(ecode1)) {
16478 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
16479 }
16480 arg1 = static_cast< PLFLT >(val1);
16481 ecode2 = SWIG_AsVal_double(args(1), &val2);
16482 if (!SWIG_IsOK(ecode2)) {
16483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
16484 }
16485 arg2 = static_cast< PLFLT >(val2);
16486 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
16487 if (!SWIG_IsOK(res3)) {
16488 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
16489 }
16490 arg3 = reinterpret_cast< char * >(buf3);
16491 ecode4 = SWIG_AsVal_double(args(3), &val4);
16492 if (!SWIG_IsOK(ecode4)) {
16493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
16494 }
16495 arg4 = static_cast< PLFLT >(val4);
16496 ecode5 = SWIG_AsVal_int(args(4), &val5);
16497 if (!SWIG_IsOK(ecode5)) {
16498 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
16499 }
16500 arg5 = static_cast< PLINT >(val5);
16501 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
16502 if (!SWIG_IsOK(res6)) {
16503 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
16504 }
16505 arg6 = reinterpret_cast< char * >(buf6);
16506 ecode7 = SWIG_AsVal_double(args(6), &val7);
16507 if (!SWIG_IsOK(ecode7)) {
16508 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
16509 }
16510 arg7 = static_cast< PLFLT >(val7);
16511 ecode8 = SWIG_AsVal_int(args(7), &val8);
16512 if (!SWIG_IsOK(ecode8)) {
16513 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
16514 }
16515 arg8 = static_cast< PLINT >(val8);
16516 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
16517 _outv = octave_value();
16518 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16519 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16520 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16521 return _out;
16522 fail:
16523 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
16524 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16525 return octave_value_list();
16526 }
16527
16528
16529 SWIG_DEFUN( plbin, _wrap_plbin, _wrap_plbin_texinfo ) {
16530 PLINT arg1 ;
16531 PLFLT *arg2 = (PLFLT *) 0 ;
16532 PLFLT *arg3 = (PLFLT *) 0 ;
16533 PLINT arg4 ;
16534 Matrix temp1 ;
16535 Matrix temp3 ;
16536 int val4 ;
16537 int ecode4 = 0 ;
16538 octave_value_list _out;
16539 octave_value_list *_outp=&_out;
16540 octave_value _outv;
16541
16542 if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
16543 SWIG_fail;
16544 }
16545 {
16546 if ( _n_dims( args(0) ) > 1 )
16547 {
16548 error( "argument must be a scalar or vector" ); SWIG_fail;
16549 }
16550 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16551 temp1 = args(0).matrix_value();
16552 arg2 = &temp1( 0, 0 );
16553 }
16554 {
16555 if ( _n_dims( args(1) ) > 1 )
16556 {
16557 error( "argument must be a scalar or vector" ); SWIG_fail;
16558 }
16559 if ( _dim( args(1), 0 ) != Alen )
16560 {
16561 error( "argument vectors must be same length" ); SWIG_fail;
16562 }
16563 temp3 = args(1).matrix_value();
16564 arg3 = &temp3( 0, 0 );
16565 }
16566 ecode4 = SWIG_AsVal_int(args(2), &val4);
16567 if (!SWIG_IsOK(ecode4)) {
16568 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
16569 }
16570 arg4 = static_cast< PLINT >(val4);
16571 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
16572 _outv = octave_value();
16573 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16574 {
16575
16576 }
16577 {
16578
16579 }
16580 return _out;
16581 fail:
16582 {
16583
16584 }
16585 {
16586
16587 }
16588 return octave_value_list();
16589 }
16590
16591
16592 SWIG_DEFUN( plbtime, _wrap_plbtime, _wrap_plbtime_texinfo ) {
16593 PLINT *arg1 = (PLINT *) 0 ;
16594 PLINT *arg2 = (PLINT *) 0 ;
16595 PLINT *arg3 = (PLINT *) 0 ;
16596 PLINT *arg4 = (PLINT *) 0 ;
16597 PLINT *arg5 = (PLINT *) 0 ;
16598 PLFLT *arg6 = (PLFLT *) 0 ;
16599 PLFLT arg7 ;
16600 PLINT temp1 ;
16601 int res1 = SWIG_TMPOBJ ;
16602 PLINT temp2 ;
16603 int res2 = SWIG_TMPOBJ ;
16604 PLINT temp3 ;
16605 int res3 = SWIG_TMPOBJ ;
16606 PLINT temp4 ;
16607 int res4 = SWIG_TMPOBJ ;
16608 PLINT temp5 ;
16609 int res5 = SWIG_TMPOBJ ;
16610 PLFLT temp6 ;
16611 int res6 = SWIG_TMPOBJ ;
16612 double val7 ;
16613 int ecode7 = 0 ;
16614 octave_value_list _out;
16615 octave_value_list *_outp=&_out;
16616 octave_value _outv;
16617
16618 arg1 = &temp1;
16619 arg2 = &temp2;
16620 arg3 = &temp3;
16621 arg4 = &temp4;
16622 arg5 = &temp5;
16623 arg6 = &temp6;
16624 if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
16625 SWIG_fail;
16626 }
16627 ecode7 = SWIG_AsVal_double(args(0), &val7);
16628 if (!SWIG_IsOK(ecode7)) {
16629 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
16630 }
16631 arg7 = static_cast< PLFLT >(val7);
16632 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
16633 _outv = octave_value();
16634 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16635 if (SWIG_IsTmpObj(res1)) {
16636 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16637 } else {
16638 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16639 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16640 }
16641 if (SWIG_IsTmpObj(res2)) {
16642 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
16643 } else {
16644 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16645 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
16646 }
16647 if (SWIG_IsTmpObj(res3)) {
16648 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
16649 } else {
16650 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16651 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
16652 }
16653 if (SWIG_IsTmpObj(res4)) {
16654 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
16655 } else {
16656 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16657 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
16658 }
16659 if (SWIG_IsTmpObj(res5)) {
16660 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
16661 } else {
16662 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16663 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16664 }
16665 if (SWIG_IsTmpObj(res6)) {
16666 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
16667 } else {
16668 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16669 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
16670 }
16671 return _out;
16672 fail:
16673 return octave_value_list();
16674 }
16675
16676
16677 SWIG_DEFUN( plbop, _wrap_plbop, _wrap_plbop_texinfo ) {
16678 octave_value_list _out;
16679 octave_value_list *_outp=&_out;
16680 octave_value _outv;
16681
16682 if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
16683 SWIG_fail;
16684 }
16685 plbop();
16686 _outv = octave_value();
16687 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16688 return _out;
16689 fail:
16690 return octave_value_list();
16691 }
16692
16693
16694 SWIG_DEFUN( plbox, _wrap_plbox, _wrap_plbox_texinfo ) {
16695 char *arg1 = (char *) 0 ;
16696 PLFLT arg2 ;
16697 PLINT arg3 ;
16698 char *arg4 = (char *) 0 ;
16699 PLFLT arg5 ;
16700 PLINT arg6 ;
16701 int res1 ;
16702 char *buf1 = 0 ;
16703 int alloc1 = 0 ;
16704 double val2 ;
16705 int ecode2 = 0 ;
16706 int val3 ;
16707 int ecode3 = 0 ;
16708 int res4 ;
16709 char *buf4 = 0 ;
16710 int alloc4 = 0 ;
16711 double val5 ;
16712 int ecode5 = 0 ;
16713 int val6 ;
16714 int ecode6 = 0 ;
16715 octave_value_list _out;
16716 octave_value_list *_outp=&_out;
16717 octave_value _outv;
16718
16719 if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
16720 SWIG_fail;
16721 }
16722 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16723 if (!SWIG_IsOK(res1)) {
16724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
16725 }
16726 arg1 = reinterpret_cast< char * >(buf1);
16727 ecode2 = SWIG_AsVal_double(args(1), &val2);
16728 if (!SWIG_IsOK(ecode2)) {
16729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
16730 }
16731 arg2 = static_cast< PLFLT >(val2);
16732 ecode3 = SWIG_AsVal_int(args(2), &val3);
16733 if (!SWIG_IsOK(ecode3)) {
16734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
16735 }
16736 arg3 = static_cast< PLINT >(val3);
16737 res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
16738 if (!SWIG_IsOK(res4)) {
16739 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
16740 }
16741 arg4 = reinterpret_cast< char * >(buf4);
16742 ecode5 = SWIG_AsVal_double(args(4), &val5);
16743 if (!SWIG_IsOK(ecode5)) {
16744 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
16745 }
16746 arg5 = static_cast< PLFLT >(val5);
16747 ecode6 = SWIG_AsVal_int(args(5), &val6);
16748 if (!SWIG_IsOK(ecode6)) {
16749 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
16750 }
16751 arg6 = static_cast< PLINT >(val6);
16752 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
16753 _outv = octave_value();
16754 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16755 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16756 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
16757 return _out;
16758 fail:
16759 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16760 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
16761 return octave_value_list();
16762 }
16763
16764
16765 SWIG_DEFUN( plbox3, _wrap_plbox3, _wrap_plbox3_texinfo ) {
16766 char *arg1 = (char *) 0 ;
16767 char *arg2 = (char *) 0 ;
16768 PLFLT arg3 ;
16769 PLINT arg4 ;
16770 char *arg5 = (char *) 0 ;
16771 char *arg6 = (char *) 0 ;
16772 PLFLT arg7 ;
16773 PLINT arg8 ;
16774 char *arg9 = (char *) 0 ;
16775 char *arg10 = (char *) 0 ;
16776 PLFLT arg11 ;
16777 PLINT arg12 ;
16778 int res1 ;
16779 char *buf1 = 0 ;
16780 int alloc1 = 0 ;
16781 int res2 ;
16782 char *buf2 = 0 ;
16783 int alloc2 = 0 ;
16784 double val3 ;
16785 int ecode3 = 0 ;
16786 int val4 ;
16787 int ecode4 = 0 ;
16788 int res5 ;
16789 char *buf5 = 0 ;
16790 int alloc5 = 0 ;
16791 int res6 ;
16792 char *buf6 = 0 ;
16793 int alloc6 = 0 ;
16794 double val7 ;
16795 int ecode7 = 0 ;
16796 int val8 ;
16797 int ecode8 = 0 ;
16798 int res9 ;
16799 char *buf9 = 0 ;
16800 int alloc9 = 0 ;
16801 int res10 ;
16802 char *buf10 = 0 ;
16803 int alloc10 = 0 ;
16804 double val11 ;
16805 int ecode11 = 0 ;
16806 int val12 ;
16807 int ecode12 = 0 ;
16808 octave_value_list _out;
16809 octave_value_list *_outp=&_out;
16810 octave_value _outv;
16811
16812 if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
16813 SWIG_fail;
16814 }
16815 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16816 if (!SWIG_IsOK(res1)) {
16817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
16818 }
16819 arg1 = reinterpret_cast< char * >(buf1);
16820 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
16821 if (!SWIG_IsOK(res2)) {
16822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
16823 }
16824 arg2 = reinterpret_cast< char * >(buf2);
16825 ecode3 = SWIG_AsVal_double(args(2), &val3);
16826 if (!SWIG_IsOK(ecode3)) {
16827 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
16828 }
16829 arg3 = static_cast< PLFLT >(val3);
16830 ecode4 = SWIG_AsVal_int(args(3), &val4);
16831 if (!SWIG_IsOK(ecode4)) {
16832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
16833 }
16834 arg4 = static_cast< PLINT >(val4);
16835 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
16836 if (!SWIG_IsOK(res5)) {
16837 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
16838 }
16839 arg5 = reinterpret_cast< char * >(buf5);
16840 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
16841 if (!SWIG_IsOK(res6)) {
16842 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
16843 }
16844 arg6 = reinterpret_cast< char * >(buf6);
16845 ecode7 = SWIG_AsVal_double(args(6), &val7);
16846 if (!SWIG_IsOK(ecode7)) {
16847 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
16848 }
16849 arg7 = static_cast< PLFLT >(val7);
16850 ecode8 = SWIG_AsVal_int(args(7), &val8);
16851 if (!SWIG_IsOK(ecode8)) {
16852 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
16853 }
16854 arg8 = static_cast< PLINT >(val8);
16855 res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
16856 if (!SWIG_IsOK(res9)) {
16857 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
16858 }
16859 arg9 = reinterpret_cast< char * >(buf9);
16860 res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
16861 if (!SWIG_IsOK(res10)) {
16862 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
16863 }
16864 arg10 = reinterpret_cast< char * >(buf10);
16865 ecode11 = SWIG_AsVal_double(args(10), &val11);
16866 if (!SWIG_IsOK(ecode11)) {
16867 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
16868 }
16869 arg11 = static_cast< PLFLT >(val11);
16870 ecode12 = SWIG_AsVal_int(args(11), &val12);
16871 if (!SWIG_IsOK(ecode12)) {
16872 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
16873 }
16874 arg12 = static_cast< PLINT >(val12);
16875 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);
16876 _outv = octave_value();
16877 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16878 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16879 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16880 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16881 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16882 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
16883 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
16884 return _out;
16885 fail:
16886 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16887 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
16888 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16889 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
16890 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
16891 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
16892 return octave_value_list();
16893 }
16894
16895
16896 SWIG_DEFUN( plcalc_world, _wrap_plcalc_world, _wrap_plcalc_world_texinfo ) {
16897 PLFLT arg1 ;
16898 PLFLT arg2 ;
16899 PLFLT *arg3 = (PLFLT *) 0 ;
16900 PLFLT *arg4 = (PLFLT *) 0 ;
16901 PLINT *arg5 = (PLINT *) 0 ;
16902 double val1 ;
16903 int ecode1 = 0 ;
16904 double val2 ;
16905 int ecode2 = 0 ;
16906 PLFLT temp3 ;
16907 int res3 = SWIG_TMPOBJ ;
16908 PLFLT temp4 ;
16909 int res4 = SWIG_TMPOBJ ;
16910 PLINT temp5 ;
16911 int res5 = SWIG_TMPOBJ ;
16912 octave_value_list _out;
16913 octave_value_list *_outp=&_out;
16914 octave_value _outv;
16915
16916 arg3 = &temp3;
16917 arg4 = &temp4;
16918 arg5 = &temp5;
16919 if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
16920 SWIG_fail;
16921 }
16922 ecode1 = SWIG_AsVal_double(args(0), &val1);
16923 if (!SWIG_IsOK(ecode1)) {
16924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
16925 }
16926 arg1 = static_cast< PLFLT >(val1);
16927 ecode2 = SWIG_AsVal_double(args(1), &val2);
16928 if (!SWIG_IsOK(ecode2)) {
16929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
16930 }
16931 arg2 = static_cast< PLFLT >(val2);
16932 plcalc_world(arg1,arg2,arg3,arg4,arg5);
16933 _outv = octave_value();
16934 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16935 if (SWIG_IsTmpObj(res3)) {
16936 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
16937 } else {
16938 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16939 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
16940 }
16941 if (SWIG_IsTmpObj(res4)) {
16942 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
16943 } else {
16944 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16945 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
16946 }
16947 if (SWIG_IsTmpObj(res5)) {
16948 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
16949 } else {
16950 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16951 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
16952 }
16953 return _out;
16954 fail:
16955 return octave_value_list();
16956 }
16957
16958
16959 SWIG_DEFUN( plclear, _wrap_plclear, _wrap_plclear_texinfo ) {
16960 octave_value_list _out;
16961 octave_value_list *_outp=&_out;
16962 octave_value _outv;
16963
16964 if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
16965 SWIG_fail;
16966 }
16967 plclear();
16968 _outv = octave_value();
16969 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16970 return _out;
16971 fail:
16972 return octave_value_list();
16973 }
16974
16975
16976 SWIG_DEFUN( plcol0, _wrap_plcol0, _wrap_plcol0_texinfo ) {
16977 PLINT arg1 ;
16978 int val1 ;
16979 int ecode1 = 0 ;
16980 octave_value_list _out;
16981 octave_value_list *_outp=&_out;
16982 octave_value _outv;
16983
16984 if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
16985 SWIG_fail;
16986 }
16987 ecode1 = SWIG_AsVal_int(args(0), &val1);
16988 if (!SWIG_IsOK(ecode1)) {
16989 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
16990 }
16991 arg1 = static_cast< PLINT >(val1);
16992 plcol0(arg1);
16993 _outv = octave_value();
16994 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16995 return _out;
16996 fail:
16997 return octave_value_list();
16998 }
16999
17000
17001 SWIG_DEFUN( plcol1, _wrap_plcol1, _wrap_plcol1_texinfo ) {
17002 PLFLT arg1 ;
17003 double val1 ;
17004 int ecode1 = 0 ;
17005 octave_value_list _out;
17006 octave_value_list *_outp=&_out;
17007 octave_value _outv;
17008
17009 if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
17010 SWIG_fail;
17011 }
17012 ecode1 = SWIG_AsVal_double(args(0), &val1);
17013 if (!SWIG_IsOK(ecode1)) {
17014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
17015 }
17016 arg1 = static_cast< PLFLT >(val1);
17017 plcol1(arg1);
17018 _outv = octave_value();
17019 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17020 return _out;
17021 fail:
17022 return octave_value_list();
17023 }
17024
17025
17026 SWIG_DEFUN( plconfigtime, _wrap_plconfigtime, _wrap_plconfigtime_texinfo ) {
17027 PLFLT arg1 ;
17028 PLFLT arg2 ;
17029 PLFLT arg3 ;
17030 PLINT arg4 ;
17031 PLBOOL arg5 ;
17032 PLINT arg6 ;
17033 PLINT arg7 ;
17034 PLINT arg8 ;
17035 PLINT arg9 ;
17036 PLINT arg10 ;
17037 PLFLT arg11 ;
17038 double val1 ;
17039 int ecode1 = 0 ;
17040 double val2 ;
17041 int ecode2 = 0 ;
17042 double val3 ;
17043 int ecode3 = 0 ;
17044 int val4 ;
17045 int ecode4 = 0 ;
17046 int val5 ;
17047 int ecode5 = 0 ;
17048 int val6 ;
17049 int ecode6 = 0 ;
17050 int val7 ;
17051 int ecode7 = 0 ;
17052 int val8 ;
17053 int ecode8 = 0 ;
17054 int val9 ;
17055 int ecode9 = 0 ;
17056 int val10 ;
17057 int ecode10 = 0 ;
17058 double val11 ;
17059 int ecode11 = 0 ;
17060 octave_value_list _out;
17061 octave_value_list *_outp=&_out;
17062 octave_value _outv;
17063
17064 if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
17065 SWIG_fail;
17066 }
17067 ecode1 = SWIG_AsVal_double(args(0), &val1);
17068 if (!SWIG_IsOK(ecode1)) {
17069 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
17070 }
17071 arg1 = static_cast< PLFLT >(val1);
17072 ecode2 = SWIG_AsVal_double(args(1), &val2);
17073 if (!SWIG_IsOK(ecode2)) {
17074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
17075 }
17076 arg2 = static_cast< PLFLT >(val2);
17077 ecode3 = SWIG_AsVal_double(args(2), &val3);
17078 if (!SWIG_IsOK(ecode3)) {
17079 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
17080 }
17081 arg3 = static_cast< PLFLT >(val3);
17082 ecode4 = SWIG_AsVal_int(args(3), &val4);
17083 if (!SWIG_IsOK(ecode4)) {
17084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
17085 }
17086 arg4 = static_cast< PLINT >(val4);
17087 ecode5 = SWIG_AsVal_int(args(4), &val5);
17088 if (!SWIG_IsOK(ecode5)) {
17089 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
17090 }
17091 arg5 = static_cast< PLBOOL >(val5);
17092 ecode6 = SWIG_AsVal_int(args(5), &val6);
17093 if (!SWIG_IsOK(ecode6)) {
17094 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
17095 }
17096 arg6 = static_cast< PLINT >(val6);
17097 ecode7 = SWIG_AsVal_int(args(6), &val7);
17098 if (!SWIG_IsOK(ecode7)) {
17099 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
17100 }
17101 arg7 = static_cast< PLINT >(val7);
17102 ecode8 = SWIG_AsVal_int(args(7), &val8);
17103 if (!SWIG_IsOK(ecode8)) {
17104 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
17105 }
17106 arg8 = static_cast< PLINT >(val8);
17107 ecode9 = SWIG_AsVal_int(args(8), &val9);
17108 if (!SWIG_IsOK(ecode9)) {
17109 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
17110 }
17111 arg9 = static_cast< PLINT >(val9);
17112 ecode10 = SWIG_AsVal_int(args(9), &val10);
17113 if (!SWIG_IsOK(ecode10)) {
17114 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
17115 }
17116 arg10 = static_cast< PLINT >(val10);
17117 ecode11 = SWIG_AsVal_double(args(10), &val11);
17118 if (!SWIG_IsOK(ecode11)) {
17119 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
17120 }
17121 arg11 = static_cast< PLFLT >(val11);
17122 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
17123 _outv = octave_value();
17124 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17125 return _out;
17126 fail:
17127 return octave_value_list();
17128 }
17129
17130
17131 SWIG_DEFUN( plctime, _wrap_plctime, _wrap_plctime_texinfo ) {
17132 PLINT arg1 ;
17133 PLINT arg2 ;
17134 PLINT arg3 ;
17135 PLINT arg4 ;
17136 PLINT arg5 ;
17137 PLFLT arg6 ;
17138 PLFLT *arg7 = (PLFLT *) 0 ;
17139 int val1 ;
17140 int ecode1 = 0 ;
17141 int val2 ;
17142 int ecode2 = 0 ;
17143 int val3 ;
17144 int ecode3 = 0 ;
17145 int val4 ;
17146 int ecode4 = 0 ;
17147 int val5 ;
17148 int ecode5 = 0 ;
17149 double val6 ;
17150 int ecode6 = 0 ;
17151 PLFLT temp7 ;
17152 int res7 = SWIG_TMPOBJ ;
17153 octave_value_list _out;
17154 octave_value_list *_outp=&_out;
17155 octave_value _outv;
17156
17157 arg7 = &temp7;
17158 if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
17159 SWIG_fail;
17160 }
17161 ecode1 = SWIG_AsVal_int(args(0), &val1);
17162 if (!SWIG_IsOK(ecode1)) {
17163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
17164 }
17165 arg1 = static_cast< PLINT >(val1);
17166 ecode2 = SWIG_AsVal_int(args(1), &val2);
17167 if (!SWIG_IsOK(ecode2)) {
17168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
17169 }
17170 arg2 = static_cast< PLINT >(val2);
17171 ecode3 = SWIG_AsVal_int(args(2), &val3);
17172 if (!SWIG_IsOK(ecode3)) {
17173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
17174 }
17175 arg3 = static_cast< PLINT >(val3);
17176 ecode4 = SWIG_AsVal_int(args(3), &val4);
17177 if (!SWIG_IsOK(ecode4)) {
17178 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
17179 }
17180 arg4 = static_cast< PLINT >(val4);
17181 ecode5 = SWIG_AsVal_int(args(4), &val5);
17182 if (!SWIG_IsOK(ecode5)) {
17183 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
17184 }
17185 arg5 = static_cast< PLINT >(val5);
17186 ecode6 = SWIG_AsVal_double(args(5), &val6);
17187 if (!SWIG_IsOK(ecode6)) {
17188 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
17189 }
17190 arg6 = static_cast< PLFLT >(val6);
17191 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
17192 _outv = octave_value();
17193 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17194 if (SWIG_IsTmpObj(res7)) {
17195 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
17196 } else {
17197 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17198 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
17199 }
17200 return _out;
17201 fail:
17202 return octave_value_list();
17203 }
17204
17205
17206 SWIG_DEFUN( plcpstrm, _wrap_plcpstrm, _wrap_plcpstrm_texinfo ) {
17207 PLINT arg1 ;
17208 PLBOOL arg2 ;
17209 int val1 ;
17210 int ecode1 = 0 ;
17211 int val2 ;
17212 int ecode2 = 0 ;
17213 octave_value_list _out;
17214 octave_value_list *_outp=&_out;
17215 octave_value _outv;
17216
17217 if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
17218 SWIG_fail;
17219 }
17220 ecode1 = SWIG_AsVal_int(args(0), &val1);
17221 if (!SWIG_IsOK(ecode1)) {
17222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
17223 }
17224 arg1 = static_cast< PLINT >(val1);
17225 ecode2 = SWIG_AsVal_int(args(1), &val2);
17226 if (!SWIG_IsOK(ecode2)) {
17227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
17228 }
17229 arg2 = static_cast< PLBOOL >(val2);
17230 plcpstrm(arg1,arg2);
17231 _outv = octave_value();
17232 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17233 return _out;
17234 fail:
17235 return octave_value_list();
17236 }
17237
17238
17239 SWIG_DEFUN( plend, _wrap_plend, _wrap_plend_texinfo ) {
17240 octave_value_list _out;
17241 octave_value_list *_outp=&_out;
17242 octave_value _outv;
17243
17244 if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
17245 SWIG_fail;
17246 }
17247 plend();
17248 _outv = octave_value();
17249 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17250 return _out;
17251 fail:
17252 return octave_value_list();
17253 }
17254
17255
17256 SWIG_DEFUN( plend1, _wrap_plend1, _wrap_plend1_texinfo ) {
17257 octave_value_list _out;
17258 octave_value_list *_outp=&_out;
17259 octave_value _outv;
17260
17261 if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
17262 SWIG_fail;
17263 }
17264 plend1();
17265 _outv = octave_value();
17266 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17267 return _out;
17268 fail:
17269 return octave_value_list();
17270 }
17271
17272
17273 SWIG_DEFUN( plenv, _wrap_plenv, _wrap_plenv_texinfo ) {
17274 PLFLT arg1 ;
17275 PLFLT arg2 ;
17276 PLFLT arg3 ;
17277 PLFLT arg4 ;
17278 PLINT arg5 ;
17279 PLINT arg6 ;
17280 double val1 ;
17281 int ecode1 = 0 ;
17282 double val2 ;
17283 int ecode2 = 0 ;
17284 double val3 ;
17285 int ecode3 = 0 ;
17286 double val4 ;
17287 int ecode4 = 0 ;
17288 int val5 ;
17289 int ecode5 = 0 ;
17290 int val6 ;
17291 int ecode6 = 0 ;
17292 octave_value_list _out;
17293 octave_value_list *_outp=&_out;
17294 octave_value _outv;
17295
17296 if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
17297 SWIG_fail;
17298 }
17299 ecode1 = SWIG_AsVal_double(args(0), &val1);
17300 if (!SWIG_IsOK(ecode1)) {
17301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
17302 }
17303 arg1 = static_cast< PLFLT >(val1);
17304 ecode2 = SWIG_AsVal_double(args(1), &val2);
17305 if (!SWIG_IsOK(ecode2)) {
17306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
17307 }
17308 arg2 = static_cast< PLFLT >(val2);
17309 ecode3 = SWIG_AsVal_double(args(2), &val3);
17310 if (!SWIG_IsOK(ecode3)) {
17311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
17312 }
17313 arg3 = static_cast< PLFLT >(val3);
17314 ecode4 = SWIG_AsVal_double(args(3), &val4);
17315 if (!SWIG_IsOK(ecode4)) {
17316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
17317 }
17318 arg4 = static_cast< PLFLT >(val4);
17319 ecode5 = SWIG_AsVal_int(args(4), &val5);
17320 if (!SWIG_IsOK(ecode5)) {
17321 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
17322 }
17323 arg5 = static_cast< PLINT >(val5);
17324 ecode6 = SWIG_AsVal_int(args(5), &val6);
17325 if (!SWIG_IsOK(ecode6)) {
17326 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
17327 }
17328 arg6 = static_cast< PLINT >(val6);
17329 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
17330 _outv = octave_value();
17331 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17332 return _out;
17333 fail:
17334 return octave_value_list();
17335 }
17336
17337
17338 SWIG_DEFUN( plenv0, _wrap_plenv0, _wrap_plenv0_texinfo ) {
17339 PLFLT arg1 ;
17340 PLFLT arg2 ;
17341 PLFLT arg3 ;
17342 PLFLT arg4 ;
17343 PLINT arg5 ;
17344 PLINT arg6 ;
17345 double val1 ;
17346 int ecode1 = 0 ;
17347 double val2 ;
17348 int ecode2 = 0 ;
17349 double val3 ;
17350 int ecode3 = 0 ;
17351 double val4 ;
17352 int ecode4 = 0 ;
17353 int val5 ;
17354 int ecode5 = 0 ;
17355 int val6 ;
17356 int ecode6 = 0 ;
17357 octave_value_list _out;
17358 octave_value_list *_outp=&_out;
17359 octave_value _outv;
17360
17361 if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
17362 SWIG_fail;
17363 }
17364 ecode1 = SWIG_AsVal_double(args(0), &val1);
17365 if (!SWIG_IsOK(ecode1)) {
17366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
17367 }
17368 arg1 = static_cast< PLFLT >(val1);
17369 ecode2 = SWIG_AsVal_double(args(1), &val2);
17370 if (!SWIG_IsOK(ecode2)) {
17371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
17372 }
17373 arg2 = static_cast< PLFLT >(val2);
17374 ecode3 = SWIG_AsVal_double(args(2), &val3);
17375 if (!SWIG_IsOK(ecode3)) {
17376 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
17377 }
17378 arg3 = static_cast< PLFLT >(val3);
17379 ecode4 = SWIG_AsVal_double(args(3), &val4);
17380 if (!SWIG_IsOK(ecode4)) {
17381 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
17382 }
17383 arg4 = static_cast< PLFLT >(val4);
17384 ecode5 = SWIG_AsVal_int(args(4), &val5);
17385 if (!SWIG_IsOK(ecode5)) {
17386 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
17387 }
17388 arg5 = static_cast< PLINT >(val5);
17389 ecode6 = SWIG_AsVal_int(args(5), &val6);
17390 if (!SWIG_IsOK(ecode6)) {
17391 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
17392 }
17393 arg6 = static_cast< PLINT >(val6);
17394 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
17395 _outv = octave_value();
17396 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17397 return _out;
17398 fail:
17399 return octave_value_list();
17400 }
17401
17402
17403 SWIG_DEFUN( pleop, _wrap_pleop, _wrap_pleop_texinfo ) {
17404 octave_value_list _out;
17405 octave_value_list *_outp=&_out;
17406 octave_value _outv;
17407
17408 if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
17409 SWIG_fail;
17410 }
17411 pleop();
17412 _outv = octave_value();
17413 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17414 return _out;
17415 fail:
17416 return octave_value_list();
17417 }
17418
17419
17420 SWIG_DEFUN( plerrx, _wrap_plerrx, _wrap_plerrx_texinfo ) {
17421 PLINT arg1 ;
17422 PLFLT *arg2 = (PLFLT *) 0 ;
17423 PLFLT *arg3 = (PLFLT *) 0 ;
17424 PLFLT *arg4 = (PLFLT *) 0 ;
17425 Matrix temp1 ;
17426 Matrix temp3 ;
17427 Matrix temp4 ;
17428 octave_value_list _out;
17429 octave_value_list *_outp=&_out;
17430 octave_value _outv;
17431
17432 if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
17433 SWIG_fail;
17434 }
17435 {
17436 if ( _n_dims( args(0) ) > 1 )
17437 {
17438 error( "argument must be a scalar or vector" ); SWIG_fail;
17439 }
17440 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17441 temp1 = args(0).matrix_value();
17442 arg2 = &temp1( 0, 0 );
17443 }
17444 {
17445 if ( _n_dims( args(1) ) > 1 )
17446 {
17447 error( "argument must be a scalar or vector" ); SWIG_fail;
17448 }
17449 if ( _dim( args(1), 0 ) != Alen )
17450 {
17451 error( "argument vectors must be same length" ); SWIG_fail;
17452 }
17453 temp3 = args(1).matrix_value();
17454 arg3 = &temp3( 0, 0 );
17455 }
17456 {
17457 if ( _n_dims( args(2) ) > 1 )
17458 {
17459 error( "argument must be a scalar or vector" ); SWIG_fail;
17460 }
17461 if ( _dim( args(2), 0 ) != Alen )
17462 {
17463 error( "argument vectors must be same length" ); SWIG_fail;
17464 }
17465 temp4 = args(2).matrix_value();
17466 arg4 = &temp4( 0, 0 );
17467 }
17468 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17469 _outv = octave_value();
17470 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17471 {
17472
17473 }
17474 {
17475
17476 }
17477 {
17478
17479 }
17480 return _out;
17481 fail:
17482 {
17483
17484 }
17485 {
17486
17487 }
17488 {
17489
17490 }
17491 return octave_value_list();
17492 }
17493
17494
17495 SWIG_DEFUN( plerry, _wrap_plerry, _wrap_plerry_texinfo ) {
17496 PLINT arg1 ;
17497 PLFLT *arg2 = (PLFLT *) 0 ;
17498 PLFLT *arg3 = (PLFLT *) 0 ;
17499 PLFLT *arg4 = (PLFLT *) 0 ;
17500 Matrix temp1 ;
17501 Matrix temp3 ;
17502 Matrix temp4 ;
17503 octave_value_list _out;
17504 octave_value_list *_outp=&_out;
17505 octave_value _outv;
17506
17507 if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
17508 SWIG_fail;
17509 }
17510 {
17511 if ( _n_dims( args(0) ) > 1 )
17512 {
17513 error( "argument must be a scalar or vector" ); SWIG_fail;
17514 }
17515 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17516 temp1 = args(0).matrix_value();
17517 arg2 = &temp1( 0, 0 );
17518 }
17519 {
17520 if ( _n_dims( args(1) ) > 1 )
17521 {
17522 error( "argument must be a scalar or vector" ); SWIG_fail;
17523 }
17524 if ( _dim( args(1), 0 ) != Alen )
17525 {
17526 error( "argument vectors must be same length" ); SWIG_fail;
17527 }
17528 temp3 = args(1).matrix_value();
17529 arg3 = &temp3( 0, 0 );
17530 }
17531 {
17532 if ( _n_dims( args(2) ) > 1 )
17533 {
17534 error( "argument must be a scalar or vector" ); SWIG_fail;
17535 }
17536 if ( _dim( args(2), 0 ) != Alen )
17537 {
17538 error( "argument vectors must be same length" ); SWIG_fail;
17539 }
17540 temp4 = args(2).matrix_value();
17541 arg4 = &temp4( 0, 0 );
17542 }
17543 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17544 _outv = octave_value();
17545 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17546 {
17547
17548 }
17549 {
17550
17551 }
17552 {
17553
17554 }
17555 return _out;
17556 fail:
17557 {
17558
17559 }
17560 {
17561
17562 }
17563 {
17564
17565 }
17566 return octave_value_list();
17567 }
17568
17569
17570 SWIG_DEFUN( plfamadv, _wrap_plfamadv, _wrap_plfamadv_texinfo ) {
17571 octave_value_list _out;
17572 octave_value_list *_outp=&_out;
17573 octave_value _outv;
17574
17575 if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
17576 SWIG_fail;
17577 }
17578 plfamadv();
17579 _outv = octave_value();
17580 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17581 return _out;
17582 fail:
17583 return octave_value_list();
17584 }
17585
17586
17587 SWIG_DEFUN( plfill, _wrap_plfill, _wrap_plfill_texinfo ) {
17588 PLINT arg1 ;
17589 PLFLT *arg2 = (PLFLT *) 0 ;
17590 PLFLT *arg3 = (PLFLT *) 0 ;
17591 Matrix temp1 ;
17592 Matrix temp3 ;
17593 octave_value_list _out;
17594 octave_value_list *_outp=&_out;
17595 octave_value _outv;
17596
17597 if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
17598 SWIG_fail;
17599 }
17600 {
17601 if ( _n_dims( args(0) ) > 1 )
17602 {
17603 error( "argument must be a scalar or vector" ); SWIG_fail;
17604 }
17605 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17606 temp1 = args(0).matrix_value();
17607 arg2 = &temp1( 0, 0 );
17608 }
17609 {
17610 if ( _n_dims( args(1) ) > 1 )
17611 {
17612 error( "argument must be a scalar or vector" ); SWIG_fail;
17613 }
17614 if ( _dim( args(1), 0 ) != Alen )
17615 {
17616 error( "argument vectors must be same length" ); SWIG_fail;
17617 }
17618 temp3 = args(1).matrix_value();
17619 arg3 = &temp3( 0, 0 );
17620 }
17621 plfill(arg1,(double const *)arg2,(double const *)arg3);
17622 _outv = octave_value();
17623 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17624 {
17625
17626 }
17627 {
17628
17629 }
17630 return _out;
17631 fail:
17632 {
17633
17634 }
17635 {
17636
17637 }
17638 return octave_value_list();
17639 }
17640
17641
17642 SWIG_DEFUN( plfill3, _wrap_plfill3, _wrap_plfill3_texinfo ) {
17643 PLINT arg1 ;
17644 PLFLT *arg2 = (PLFLT *) 0 ;
17645 PLFLT *arg3 = (PLFLT *) 0 ;
17646 PLFLT *arg4 = (PLFLT *) 0 ;
17647 Matrix temp1 ;
17648 Matrix temp3 ;
17649 Matrix temp4 ;
17650 octave_value_list _out;
17651 octave_value_list *_outp=&_out;
17652 octave_value _outv;
17653
17654 if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
17655 SWIG_fail;
17656 }
17657 {
17658 if ( _n_dims( args(0) ) > 1 )
17659 {
17660 error( "argument must be a scalar or vector" ); SWIG_fail;
17661 }
17662 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17663 temp1 = args(0).matrix_value();
17664 arg2 = &temp1( 0, 0 );
17665 }
17666 {
17667 if ( _n_dims( args(1) ) > 1 )
17668 {
17669 error( "argument must be a scalar or vector" ); SWIG_fail;
17670 }
17671 if ( _dim( args(1), 0 ) != Alen )
17672 {
17673 error( "argument vectors must be same length" ); SWIG_fail;
17674 }
17675 temp3 = args(1).matrix_value();
17676 arg3 = &temp3( 0, 0 );
17677 }
17678 {
17679 if ( _n_dims( args(2) ) > 1 )
17680 {
17681 error( "argument must be a scalar or vector" ); SWIG_fail;
17682 }
17683 if ( _dim( args(2), 0 ) != Alen )
17684 {
17685 error( "argument vectors must be same length" ); SWIG_fail;
17686 }
17687 temp4 = args(2).matrix_value();
17688 arg4 = &temp4( 0, 0 );
17689 }
17690 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
17691 _outv = octave_value();
17692 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17693 {
17694
17695 }
17696 {
17697
17698 }
17699 {
17700
17701 }
17702 return _out;
17703 fail:
17704 {
17705
17706 }
17707 {
17708
17709 }
17710 {
17711
17712 }
17713 return octave_value_list();
17714 }
17715
17716
17717 SWIG_DEFUN( plgradient, _wrap_plgradient, _wrap_plgradient_texinfo ) {
17718 PLINT arg1 ;
17719 PLFLT *arg2 = (PLFLT *) 0 ;
17720 PLFLT *arg3 = (PLFLT *) 0 ;
17721 PLFLT arg4 ;
17722 Matrix temp1 ;
17723 Matrix temp3 ;
17724 double val4 ;
17725 int ecode4 = 0 ;
17726 octave_value_list _out;
17727 octave_value_list *_outp=&_out;
17728 octave_value _outv;
17729
17730 if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
17731 SWIG_fail;
17732 }
17733 {
17734 if ( _n_dims( args(0) ) > 1 )
17735 {
17736 error( "argument must be a scalar or vector" ); SWIG_fail;
17737 }
17738 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17739 temp1 = args(0).matrix_value();
17740 arg2 = &temp1( 0, 0 );
17741 }
17742 {
17743 if ( _n_dims( args(1) ) > 1 )
17744 {
17745 error( "argument must be a scalar or vector" ); SWIG_fail;
17746 }
17747 if ( _dim( args(1), 0 ) != Alen )
17748 {
17749 error( "argument vectors must be same length" ); SWIG_fail;
17750 }
17751 temp3 = args(1).matrix_value();
17752 arg3 = &temp3( 0, 0 );
17753 }
17754 ecode4 = SWIG_AsVal_double(args(2), &val4);
17755 if (!SWIG_IsOK(ecode4)) {
17756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
17757 }
17758 arg4 = static_cast< PLFLT >(val4);
17759 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
17760 _outv = octave_value();
17761 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17762 {
17763
17764 }
17765 {
17766
17767 }
17768 return _out;
17769 fail:
17770 {
17771
17772 }
17773 {
17774
17775 }
17776 return octave_value_list();
17777 }
17778
17779
17780 SWIG_DEFUN( plflush, _wrap_plflush, _wrap_plflush_texinfo ) {
17781 octave_value_list _out;
17782 octave_value_list *_outp=&_out;
17783 octave_value _outv;
17784
17785 if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
17786 SWIG_fail;
17787 }
17788 plflush();
17789 _outv = octave_value();
17790 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17791 return _out;
17792 fail:
17793 return octave_value_list();
17794 }
17795
17796
17797 SWIG_DEFUN( plfont, _wrap_plfont, _wrap_plfont_texinfo ) {
17798 PLINT arg1 ;
17799 int val1 ;
17800 int ecode1 = 0 ;
17801 octave_value_list _out;
17802 octave_value_list *_outp=&_out;
17803 octave_value _outv;
17804
17805 if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
17806 SWIG_fail;
17807 }
17808 ecode1 = SWIG_AsVal_int(args(0), &val1);
17809 if (!SWIG_IsOK(ecode1)) {
17810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
17811 }
17812 arg1 = static_cast< PLINT >(val1);
17813 plfont(arg1);
17814 _outv = octave_value();
17815 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17816 return _out;
17817 fail:
17818 return octave_value_list();
17819 }
17820
17821
17822 SWIG_DEFUN( plfontld, _wrap_plfontld, _wrap_plfontld_texinfo ) {
17823 PLINT arg1 ;
17824 int val1 ;
17825 int ecode1 = 0 ;
17826 octave_value_list _out;
17827 octave_value_list *_outp=&_out;
17828 octave_value _outv;
17829
17830 if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
17831 SWIG_fail;
17832 }
17833 ecode1 = SWIG_AsVal_int(args(0), &val1);
17834 if (!SWIG_IsOK(ecode1)) {
17835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
17836 }
17837 arg1 = static_cast< PLINT >(val1);
17838 plfontld(arg1);
17839 _outv = octave_value();
17840 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17841 return _out;
17842 fail:
17843 return octave_value_list();
17844 }
17845
17846
17847 SWIG_DEFUN( plgchr, _wrap_plgchr, _wrap_plgchr_texinfo ) {
17848 PLFLT *arg1 = (PLFLT *) 0 ;
17849 PLFLT *arg2 = (PLFLT *) 0 ;
17850 PLFLT temp1 ;
17851 int res1 = SWIG_TMPOBJ ;
17852 PLFLT temp2 ;
17853 int res2 = SWIG_TMPOBJ ;
17854 octave_value_list _out;
17855 octave_value_list *_outp=&_out;
17856 octave_value _outv;
17857
17858 arg1 = &temp1;
17859 arg2 = &temp2;
17860 if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
17861 SWIG_fail;
17862 }
17863 plgchr(arg1,arg2);
17864 _outv = octave_value();
17865 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17866 if (SWIG_IsTmpObj(res1)) {
17867 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
17868 } else {
17869 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17870 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
17871 }
17872 if (SWIG_IsTmpObj(res2)) {
17873 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
17874 } else {
17875 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17876 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
17877 }
17878 return _out;
17879 fail:
17880 return octave_value_list();
17881 }
17882
17883
17884 SWIG_DEFUN( plgcol0, _wrap_plgcol0, _wrap_plgcol0_texinfo ) {
17885 PLINT arg1 ;
17886 PLINT *arg2 = (PLINT *) 0 ;
17887 PLINT *arg3 = (PLINT *) 0 ;
17888 PLINT *arg4 = (PLINT *) 0 ;
17889 int val1 ;
17890 int ecode1 = 0 ;
17891 PLINT temp2 ;
17892 int res2 = SWIG_TMPOBJ ;
17893 PLINT temp3 ;
17894 int res3 = SWIG_TMPOBJ ;
17895 PLINT temp4 ;
17896 int res4 = SWIG_TMPOBJ ;
17897 octave_value_list _out;
17898 octave_value_list *_outp=&_out;
17899 octave_value _outv;
17900
17901 arg2 = &temp2;
17902 arg3 = &temp3;
17903 arg4 = &temp4;
17904 if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
17905 SWIG_fail;
17906 }
17907 ecode1 = SWIG_AsVal_int(args(0), &val1);
17908 if (!SWIG_IsOK(ecode1)) {
17909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
17910 }
17911 arg1 = static_cast< PLINT >(val1);
17912 plgcol0(arg1,arg2,arg3,arg4);
17913 _outv = octave_value();
17914 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17915 if (SWIG_IsTmpObj(res2)) {
17916 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17917 } else {
17918 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17919 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17920 }
17921 if (SWIG_IsTmpObj(res3)) {
17922 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17923 } else {
17924 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17925 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17926 }
17927 if (SWIG_IsTmpObj(res4)) {
17928 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17929 } else {
17930 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17931 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17932 }
17933 return _out;
17934 fail:
17935 return octave_value_list();
17936 }
17937
17938
17939 SWIG_DEFUN( plgcol0a, _wrap_plgcol0a, _wrap_plgcol0a_texinfo ) {
17940 PLINT arg1 ;
17941 PLINT *arg2 = (PLINT *) 0 ;
17942 PLINT *arg3 = (PLINT *) 0 ;
17943 PLINT *arg4 = (PLINT *) 0 ;
17944 PLFLT *arg5 = (PLFLT *) 0 ;
17945 int val1 ;
17946 int ecode1 = 0 ;
17947 PLINT temp2 ;
17948 int res2 = SWIG_TMPOBJ ;
17949 PLINT temp3 ;
17950 int res3 = SWIG_TMPOBJ ;
17951 PLINT temp4 ;
17952 int res4 = SWIG_TMPOBJ ;
17953 PLFLT temp5 ;
17954 int res5 = SWIG_TMPOBJ ;
17955 octave_value_list _out;
17956 octave_value_list *_outp=&_out;
17957 octave_value _outv;
17958
17959 arg2 = &temp2;
17960 arg3 = &temp3;
17961 arg4 = &temp4;
17962 arg5 = &temp5;
17963 if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
17964 SWIG_fail;
17965 }
17966 ecode1 = SWIG_AsVal_int(args(0), &val1);
17967 if (!SWIG_IsOK(ecode1)) {
17968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
17969 }
17970 arg1 = static_cast< PLINT >(val1);
17971 plgcol0a(arg1,arg2,arg3,arg4,arg5);
17972 _outv = octave_value();
17973 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17974 if (SWIG_IsTmpObj(res2)) {
17975 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
17976 } else {
17977 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17978 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
17979 }
17980 if (SWIG_IsTmpObj(res3)) {
17981 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
17982 } else {
17983 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17984 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
17985 }
17986 if (SWIG_IsTmpObj(res4)) {
17987 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
17988 } else {
17989 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17990 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
17991 }
17992 if (SWIG_IsTmpObj(res5)) {
17993 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
17994 } else {
17995 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17996 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
17997 }
17998 return _out;
17999 fail:
18000 return octave_value_list();
18001 }
18002
18003
18004 SWIG_DEFUN( plgcolbg, _wrap_plgcolbg, _wrap_plgcolbg_texinfo ) {
18005 PLINT *arg1 = (PLINT *) 0 ;
18006 PLINT *arg2 = (PLINT *) 0 ;
18007 PLINT *arg3 = (PLINT *) 0 ;
18008 PLINT temp1 ;
18009 int res1 = SWIG_TMPOBJ ;
18010 PLINT temp2 ;
18011 int res2 = SWIG_TMPOBJ ;
18012 PLINT temp3 ;
18013 int res3 = SWIG_TMPOBJ ;
18014 octave_value_list _out;
18015 octave_value_list *_outp=&_out;
18016 octave_value _outv;
18017
18018 arg1 = &temp1;
18019 arg2 = &temp2;
18020 arg3 = &temp3;
18021 if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
18022 SWIG_fail;
18023 }
18024 plgcolbg(arg1,arg2,arg3);
18025 _outv = octave_value();
18026 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18027 if (SWIG_IsTmpObj(res1)) {
18028 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18029 } else {
18030 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18031 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18032 }
18033 if (SWIG_IsTmpObj(res2)) {
18034 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18035 } else {
18036 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18037 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18038 }
18039 if (SWIG_IsTmpObj(res3)) {
18040 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18041 } else {
18042 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18043 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18044 }
18045 return _out;
18046 fail:
18047 return octave_value_list();
18048 }
18049
18050
18051 SWIG_DEFUN( plgcolbga, _wrap_plgcolbga, _wrap_plgcolbga_texinfo ) {
18052 PLINT *arg1 = (PLINT *) 0 ;
18053 PLINT *arg2 = (PLINT *) 0 ;
18054 PLINT *arg3 = (PLINT *) 0 ;
18055 PLFLT *arg4 = (PLFLT *) 0 ;
18056 PLINT temp1 ;
18057 int res1 = SWIG_TMPOBJ ;
18058 PLINT temp2 ;
18059 int res2 = SWIG_TMPOBJ ;
18060 PLINT temp3 ;
18061 int res3 = SWIG_TMPOBJ ;
18062 PLFLT temp4 ;
18063 int res4 = SWIG_TMPOBJ ;
18064 octave_value_list _out;
18065 octave_value_list *_outp=&_out;
18066 octave_value _outv;
18067
18068 arg1 = &temp1;
18069 arg2 = &temp2;
18070 arg3 = &temp3;
18071 arg4 = &temp4;
18072 if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
18073 SWIG_fail;
18074 }
18075 plgcolbga(arg1,arg2,arg3,arg4);
18076 _outv = octave_value();
18077 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18078 if (SWIG_IsTmpObj(res1)) {
18079 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18080 } else {
18081 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18082 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18083 }
18084 if (SWIG_IsTmpObj(res2)) {
18085 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18086 } else {
18087 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18088 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18089 }
18090 if (SWIG_IsTmpObj(res3)) {
18091 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18092 } else {
18093 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18094 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18095 }
18096 if (SWIG_IsTmpObj(res4)) {
18097 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18098 } else {
18099 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18100 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18101 }
18102 return _out;
18103 fail:
18104 return octave_value_list();
18105 }
18106
18107
18108 SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
18109 PLINT *arg1 = (PLINT *) 0 ;
18110 PLINT temp1 ;
18111 int res1 = SWIG_TMPOBJ ;
18112 octave_value_list _out;
18113 octave_value_list *_outp=&_out;
18114 octave_value _outv;
18115
18116 arg1 = &temp1;
18117 if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
18118 SWIG_fail;
18119 }
18120 plgcompression(arg1);
18121 _outv = octave_value();
18122 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18123 if (SWIG_IsTmpObj(res1)) {
18124 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18125 } else {
18126 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18127 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18128 }
18129 return _out;
18130 fail:
18131 return octave_value_list();
18132 }
18133
18134
18135 SWIG_DEFUN( plgdev, _wrap_plgdev, _wrap_plgdev_texinfo ) {
18136 char *arg1 = (char *) 0 ;
18137 char local_string1[80] ;
18138 size_t local_string_length1 ;
18139 charMatrix local_charMatrix1 ;
18140 octave_value_list retval1 ;
18141 octave_value_list _out;
18142 octave_value_list *_outp=&_out;
18143 octave_value _outv;
18144
18145 {
18146 arg1 = local_string1;
18147 }
18148 if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
18149 SWIG_fail;
18150 }
18151 plgdev(arg1);
18152 _outv = octave_value();
18153 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18154 {
18155 local_string_length1 = strlen( local_string1 );
18156 local_charMatrix1 = charMatrix( 1, local_string_length1 );
18157 local_charMatrix1.insert( local_string1, 0, 0 );
18158 retval1( 0 ) = octave_value( local_charMatrix1 );
18159 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18160 }
18161 return _out;
18162 fail:
18163 return octave_value_list();
18164 }
18165
18166
18167 SWIG_DEFUN( plgdidev, _wrap_plgdidev, _wrap_plgdidev_texinfo ) {
18168 PLFLT *arg1 = (PLFLT *) 0 ;
18169 PLFLT *arg2 = (PLFLT *) 0 ;
18170 PLFLT *arg3 = (PLFLT *) 0 ;
18171 PLFLT *arg4 = (PLFLT *) 0 ;
18172 PLFLT temp1 ;
18173 int res1 = SWIG_TMPOBJ ;
18174 PLFLT temp2 ;
18175 int res2 = SWIG_TMPOBJ ;
18176 PLFLT temp3 ;
18177 int res3 = SWIG_TMPOBJ ;
18178 PLFLT temp4 ;
18179 int res4 = SWIG_TMPOBJ ;
18180 octave_value_list _out;
18181 octave_value_list *_outp=&_out;
18182 octave_value _outv;
18183
18184 arg1 = &temp1;
18185 arg2 = &temp2;
18186 arg3 = &temp3;
18187 arg4 = &temp4;
18188 if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
18189 SWIG_fail;
18190 }
18191 plgdidev(arg1,arg2,arg3,arg4);
18192 _outv = octave_value();
18193 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18194 if (SWIG_IsTmpObj(res1)) {
18195 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18196 } else {
18197 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18198 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18199 }
18200 if (SWIG_IsTmpObj(res2)) {
18201 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18202 } else {
18203 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18204 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18205 }
18206 if (SWIG_IsTmpObj(res3)) {
18207 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18208 } else {
18209 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18210 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18211 }
18212 if (SWIG_IsTmpObj(res4)) {
18213 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18214 } else {
18215 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18216 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18217 }
18218 return _out;
18219 fail:
18220 return octave_value_list();
18221 }
18222
18223
18224 SWIG_DEFUN( plgdiori, _wrap_plgdiori, _wrap_plgdiori_texinfo ) {
18225 PLFLT *arg1 = (PLFLT *) 0 ;
18226 PLFLT temp1 ;
18227 int res1 = SWIG_TMPOBJ ;
18228 octave_value_list _out;
18229 octave_value_list *_outp=&_out;
18230 octave_value _outv;
18231
18232 arg1 = &temp1;
18233 if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
18234 SWIG_fail;
18235 }
18236 plgdiori(arg1);
18237 _outv = octave_value();
18238 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18239 if (SWIG_IsTmpObj(res1)) {
18240 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18241 } else {
18242 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18243 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18244 }
18245 return _out;
18246 fail:
18247 return octave_value_list();
18248 }
18249
18250
18251 SWIG_DEFUN( plgdiplt, _wrap_plgdiplt, _wrap_plgdiplt_texinfo ) {
18252 PLFLT *arg1 = (PLFLT *) 0 ;
18253 PLFLT *arg2 = (PLFLT *) 0 ;
18254 PLFLT *arg3 = (PLFLT *) 0 ;
18255 PLFLT *arg4 = (PLFLT *) 0 ;
18256 PLFLT temp1 ;
18257 int res1 = SWIG_TMPOBJ ;
18258 PLFLT temp2 ;
18259 int res2 = SWIG_TMPOBJ ;
18260 PLFLT temp3 ;
18261 int res3 = SWIG_TMPOBJ ;
18262 PLFLT temp4 ;
18263 int res4 = SWIG_TMPOBJ ;
18264 octave_value_list _out;
18265 octave_value_list *_outp=&_out;
18266 octave_value _outv;
18267
18268 arg1 = &temp1;
18269 arg2 = &temp2;
18270 arg3 = &temp3;
18271 arg4 = &temp4;
18272 if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
18273 SWIG_fail;
18274 }
18275 plgdiplt(arg1,arg2,arg3,arg4);
18276 _outv = octave_value();
18277 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18278 if (SWIG_IsTmpObj(res1)) {
18279 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18280 } else {
18281 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18282 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18283 }
18284 if (SWIG_IsTmpObj(res2)) {
18285 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18286 } else {
18287 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18288 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18289 }
18290 if (SWIG_IsTmpObj(res3)) {
18291 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18292 } else {
18293 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18294 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18295 }
18296 if (SWIG_IsTmpObj(res4)) {
18297 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18298 } else {
18299 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18300 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18301 }
18302 return _out;
18303 fail:
18304 return octave_value_list();
18305 }
18306
18307
18308 SWIG_DEFUN( plgfam, _wrap_plgfam, _wrap_plgfam_texinfo ) {
18309 PLINT *arg1 = (PLINT *) 0 ;
18310 PLINT *arg2 = (PLINT *) 0 ;
18311 PLINT *arg3 = (PLINT *) 0 ;
18312 PLINT temp1 ;
18313 int res1 = SWIG_TMPOBJ ;
18314 PLINT temp2 ;
18315 int res2 = SWIG_TMPOBJ ;
18316 PLINT temp3 ;
18317 int res3 = SWIG_TMPOBJ ;
18318 octave_value_list _out;
18319 octave_value_list *_outp=&_out;
18320 octave_value _outv;
18321
18322 arg1 = &temp1;
18323 arg2 = &temp2;
18324 arg3 = &temp3;
18325 if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
18326 SWIG_fail;
18327 }
18328 plgfam(arg1,arg2,arg3);
18329 _outv = octave_value();
18330 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18331 if (SWIG_IsTmpObj(res1)) {
18332 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18333 } else {
18334 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18335 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18336 }
18337 if (SWIG_IsTmpObj(res2)) {
18338 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18339 } else {
18340 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18341 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18342 }
18343 if (SWIG_IsTmpObj(res3)) {
18344 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18345 } else {
18346 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18347 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18348 }
18349 return _out;
18350 fail:
18351 return octave_value_list();
18352 }
18353
18354
18355 SWIG_DEFUN( plgfci, _wrap_plgfci, _wrap_plgfci_texinfo ) {
18356 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
18357 PLUNICODE temp1 ;
18358 int res1 = SWIG_TMPOBJ ;
18359 octave_value_list _out;
18360 octave_value_list *_outp=&_out;
18361 octave_value _outv;
18362
18363 arg1 = &temp1;
18364 if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
18365 SWIG_fail;
18366 }
18367 plgfci(arg1);
18368 _outv = octave_value();
18369 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18370 if (SWIG_IsTmpObj(res1)) {
18371 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
18372 } else {
18373 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18374 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
18375 }
18376 return _out;
18377 fail:
18378 return octave_value_list();
18379 }
18380
18381
18382 SWIG_DEFUN( plgfnam, _wrap_plgfnam, _wrap_plgfnam_texinfo ) {
18383 char *arg1 = (char *) 0 ;
18384 char local_string1[80] ;
18385 size_t local_string_length1 ;
18386 charMatrix local_charMatrix1 ;
18387 octave_value_list retval1 ;
18388 octave_value_list _out;
18389 octave_value_list *_outp=&_out;
18390 octave_value _outv;
18391
18392 {
18393 arg1 = local_string1;
18394 }
18395 if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
18396 SWIG_fail;
18397 }
18398 plgfnam(arg1);
18399 _outv = octave_value();
18400 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18401 {
18402 local_string_length1 = strlen( local_string1 );
18403 local_charMatrix1 = charMatrix( 1, local_string_length1 );
18404 local_charMatrix1.insert( local_string1, 0, 0 );
18405 retval1( 0 ) = octave_value( local_charMatrix1 );
18406 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18407 }
18408 return _out;
18409 fail:
18410 return octave_value_list();
18411 }
18412
18413
18414 SWIG_DEFUN( plgfont, _wrap_plgfont, _wrap_plgfont_texinfo ) {
18415 PLINT *arg1 = (PLINT *) 0 ;
18416 PLINT *arg2 = (PLINT *) 0 ;
18417 PLINT *arg3 = (PLINT *) 0 ;
18418 PLINT temp1 ;
18419 int res1 = SWIG_TMPOBJ ;
18420 PLINT temp2 ;
18421 int res2 = SWIG_TMPOBJ ;
18422 PLINT temp3 ;
18423 int res3 = SWIG_TMPOBJ ;
18424 octave_value_list _out;
18425 octave_value_list *_outp=&_out;
18426 octave_value _outv;
18427
18428 arg1 = &temp1;
18429 arg2 = &temp2;
18430 arg3 = &temp3;
18431 if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
18432 SWIG_fail;
18433 }
18434 plgfont(arg1,arg2,arg3);
18435 _outv = octave_value();
18436 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18437 if (SWIG_IsTmpObj(res1)) {
18438 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18439 } else {
18440 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18441 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18442 }
18443 if (SWIG_IsTmpObj(res2)) {
18444 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18445 } else {
18446 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18447 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18448 }
18449 if (SWIG_IsTmpObj(res3)) {
18450 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18451 } else {
18452 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18453 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18454 }
18455 return _out;
18456 fail:
18457 return octave_value_list();
18458 }
18459
18460
18461 SWIG_DEFUN( plglevel, _wrap_plglevel, _wrap_plglevel_texinfo ) {
18462 PLINT *arg1 = (PLINT *) 0 ;
18463 PLINT temp1 ;
18464 int res1 = SWIG_TMPOBJ ;
18465 octave_value_list _out;
18466 octave_value_list *_outp=&_out;
18467 octave_value _outv;
18468
18469 arg1 = &temp1;
18470 if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
18471 SWIG_fail;
18472 }
18473 plglevel(arg1);
18474 _outv = octave_value();
18475 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18476 if (SWIG_IsTmpObj(res1)) {
18477 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18478 } else {
18479 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18480 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18481 }
18482 return _out;
18483 fail:
18484 return octave_value_list();
18485 }
18486
18487
18488 SWIG_DEFUN( plgpage, _wrap_plgpage, _wrap_plgpage_texinfo ) {
18489 PLFLT *arg1 = (PLFLT *) 0 ;
18490 PLFLT *arg2 = (PLFLT *) 0 ;
18491 PLINT *arg3 = (PLINT *) 0 ;
18492 PLINT *arg4 = (PLINT *) 0 ;
18493 PLINT *arg5 = (PLINT *) 0 ;
18494 PLINT *arg6 = (PLINT *) 0 ;
18495 PLFLT temp1 ;
18496 int res1 = SWIG_TMPOBJ ;
18497 PLFLT temp2 ;
18498 int res2 = SWIG_TMPOBJ ;
18499 PLINT temp3 ;
18500 int res3 = SWIG_TMPOBJ ;
18501 PLINT temp4 ;
18502 int res4 = SWIG_TMPOBJ ;
18503 PLINT temp5 ;
18504 int res5 = SWIG_TMPOBJ ;
18505 PLINT temp6 ;
18506 int res6 = SWIG_TMPOBJ ;
18507 octave_value_list _out;
18508 octave_value_list *_outp=&_out;
18509 octave_value _outv;
18510
18511 arg1 = &temp1;
18512 arg2 = &temp2;
18513 arg3 = &temp3;
18514 arg4 = &temp4;
18515 arg5 = &temp5;
18516 arg6 = &temp6;
18517 if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
18518 SWIG_fail;
18519 }
18520 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
18521 _outv = octave_value();
18522 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18523 if (SWIG_IsTmpObj(res1)) {
18524 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18525 } else {
18526 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18527 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18528 }
18529 if (SWIG_IsTmpObj(res2)) {
18530 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18531 } else {
18532 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18533 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18534 }
18535 if (SWIG_IsTmpObj(res3)) {
18536 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
18537 } else {
18538 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18539 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
18540 }
18541 if (SWIG_IsTmpObj(res4)) {
18542 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
18543 } else {
18544 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18545 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
18546 }
18547 if (SWIG_IsTmpObj(res5)) {
18548 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
18549 } else {
18550 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18551 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
18552 }
18553 if (SWIG_IsTmpObj(res6)) {
18554 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
18555 } else {
18556 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18557 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
18558 }
18559 return _out;
18560 fail:
18561 return octave_value_list();
18562 }
18563
18564
18565 SWIG_DEFUN( plgra, _wrap_plgra, _wrap_plgra_texinfo ) {
18566 octave_value_list _out;
18567 octave_value_list *_outp=&_out;
18568 octave_value _outv;
18569
18570 if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
18571 SWIG_fail;
18572 }
18573 plgra();
18574 _outv = octave_value();
18575 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18576 return _out;
18577 fail:
18578 return octave_value_list();
18579 }
18580
18581
18582 SWIG_DEFUN( plgspa, _wrap_plgspa, _wrap_plgspa_texinfo ) {
18583 PLFLT *arg1 = (PLFLT *) 0 ;
18584 PLFLT *arg2 = (PLFLT *) 0 ;
18585 PLFLT *arg3 = (PLFLT *) 0 ;
18586 PLFLT *arg4 = (PLFLT *) 0 ;
18587 PLFLT temp1 ;
18588 int res1 = SWIG_TMPOBJ ;
18589 PLFLT temp2 ;
18590 int res2 = SWIG_TMPOBJ ;
18591 PLFLT temp3 ;
18592 int res3 = SWIG_TMPOBJ ;
18593 PLFLT temp4 ;
18594 int res4 = SWIG_TMPOBJ ;
18595 octave_value_list _out;
18596 octave_value_list *_outp=&_out;
18597 octave_value _outv;
18598
18599 arg1 = &temp1;
18600 arg2 = &temp2;
18601 arg3 = &temp3;
18602 arg4 = &temp4;
18603 if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
18604 SWIG_fail;
18605 }
18606 plgspa(arg1,arg2,arg3,arg4);
18607 _outv = octave_value();
18608 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18609 if (SWIG_IsTmpObj(res1)) {
18610 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18611 } else {
18612 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18613 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18614 }
18615 if (SWIG_IsTmpObj(res2)) {
18616 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18617 } else {
18618 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18619 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18620 }
18621 if (SWIG_IsTmpObj(res3)) {
18622 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18623 } else {
18624 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18625 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18626 }
18627 if (SWIG_IsTmpObj(res4)) {
18628 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18629 } else {
18630 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18631 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18632 }
18633 return _out;
18634 fail:
18635 return octave_value_list();
18636 }
18637
18638
18639 SWIG_DEFUN( plgstrm, _wrap_plgstrm, _wrap_plgstrm_texinfo ) {
18640 PLINT *arg1 = (PLINT *) 0 ;
18641 PLINT temp1 ;
18642 int res1 = SWIG_TMPOBJ ;
18643 octave_value_list _out;
18644 octave_value_list *_outp=&_out;
18645 octave_value _outv;
18646
18647 arg1 = &temp1;
18648 if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
18649 SWIG_fail;
18650 }
18651 plgstrm(arg1);
18652 _outv = octave_value();
18653 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18654 if (SWIG_IsTmpObj(res1)) {
18655 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18656 } else {
18657 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18658 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18659 }
18660 return _out;
18661 fail:
18662 return octave_value_list();
18663 }
18664
18665
18666 SWIG_DEFUN( plgver, _wrap_plgver, _wrap_plgver_texinfo ) {
18667 char *arg1 = (char *) 0 ;
18668 char local_string1[80] ;
18669 size_t local_string_length1 ;
18670 charMatrix local_charMatrix1 ;
18671 octave_value_list retval1 ;
18672 octave_value_list _out;
18673 octave_value_list *_outp=&_out;
18674 octave_value _outv;
18675
18676 {
18677 arg1 = local_string1;
18678 }
18679 if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
18680 SWIG_fail;
18681 }
18682 plgver(arg1);
18683 _outv = octave_value();
18684 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18685 {
18686 local_string_length1 = strlen( local_string1 );
18687 local_charMatrix1 = charMatrix( 1, local_string_length1 );
18688 local_charMatrix1.insert( local_string1, 0, 0 );
18689 retval1( 0 ) = octave_value( local_charMatrix1 );
18690 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
18691 }
18692 return _out;
18693 fail:
18694 return octave_value_list();
18695 }
18696
18697
18698 SWIG_DEFUN( plgvpd, _wrap_plgvpd, _wrap_plgvpd_texinfo ) {
18699 PLFLT *arg1 = (PLFLT *) 0 ;
18700 PLFLT *arg2 = (PLFLT *) 0 ;
18701 PLFLT *arg3 = (PLFLT *) 0 ;
18702 PLFLT *arg4 = (PLFLT *) 0 ;
18703 PLFLT temp1 ;
18704 int res1 = SWIG_TMPOBJ ;
18705 PLFLT temp2 ;
18706 int res2 = SWIG_TMPOBJ ;
18707 PLFLT temp3 ;
18708 int res3 = SWIG_TMPOBJ ;
18709 PLFLT temp4 ;
18710 int res4 = SWIG_TMPOBJ ;
18711 octave_value_list _out;
18712 octave_value_list *_outp=&_out;
18713 octave_value _outv;
18714
18715 arg1 = &temp1;
18716 arg2 = &temp2;
18717 arg3 = &temp3;
18718 arg4 = &temp4;
18719 if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
18720 SWIG_fail;
18721 }
18722 plgvpd(arg1,arg2,arg3,arg4);
18723 _outv = octave_value();
18724 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18725 if (SWIG_IsTmpObj(res1)) {
18726 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18727 } else {
18728 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18729 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18730 }
18731 if (SWIG_IsTmpObj(res2)) {
18732 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18733 } else {
18734 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18735 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18736 }
18737 if (SWIG_IsTmpObj(res3)) {
18738 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18739 } else {
18740 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18741 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18742 }
18743 if (SWIG_IsTmpObj(res4)) {
18744 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18745 } else {
18746 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18747 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18748 }
18749 return _out;
18750 fail:
18751 return octave_value_list();
18752 }
18753
18754
18755 SWIG_DEFUN( plgvpw, _wrap_plgvpw, _wrap_plgvpw_texinfo ) {
18756 PLFLT *arg1 = (PLFLT *) 0 ;
18757 PLFLT *arg2 = (PLFLT *) 0 ;
18758 PLFLT *arg3 = (PLFLT *) 0 ;
18759 PLFLT *arg4 = (PLFLT *) 0 ;
18760 PLFLT temp1 ;
18761 int res1 = SWIG_TMPOBJ ;
18762 PLFLT temp2 ;
18763 int res2 = SWIG_TMPOBJ ;
18764 PLFLT temp3 ;
18765 int res3 = SWIG_TMPOBJ ;
18766 PLFLT temp4 ;
18767 int res4 = SWIG_TMPOBJ ;
18768 octave_value_list _out;
18769 octave_value_list *_outp=&_out;
18770 octave_value _outv;
18771
18772 arg1 = &temp1;
18773 arg2 = &temp2;
18774 arg3 = &temp3;
18775 arg4 = &temp4;
18776 if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
18777 SWIG_fail;
18778 }
18779 plgvpw(arg1,arg2,arg3,arg4);
18780 _outv = octave_value();
18781 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18782 if (SWIG_IsTmpObj(res1)) {
18783 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18784 } else {
18785 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18786 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18787 }
18788 if (SWIG_IsTmpObj(res2)) {
18789 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18790 } else {
18791 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18792 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18793 }
18794 if (SWIG_IsTmpObj(res3)) {
18795 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
18796 } else {
18797 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18798 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
18799 }
18800 if (SWIG_IsTmpObj(res4)) {
18801 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
18802 } else {
18803 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18804 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
18805 }
18806 return _out;
18807 fail:
18808 return octave_value_list();
18809 }
18810
18811
18812 SWIG_DEFUN( plgxax, _wrap_plgxax, _wrap_plgxax_texinfo ) {
18813 PLINT *arg1 = (PLINT *) 0 ;
18814 PLINT *arg2 = (PLINT *) 0 ;
18815 PLINT temp1 ;
18816 int res1 = SWIG_TMPOBJ ;
18817 PLINT temp2 ;
18818 int res2 = SWIG_TMPOBJ ;
18819 octave_value_list _out;
18820 octave_value_list *_outp=&_out;
18821 octave_value _outv;
18822
18823 arg1 = &temp1;
18824 arg2 = &temp2;
18825 if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
18826 SWIG_fail;
18827 }
18828 plgxax(arg1,arg2);
18829 _outv = octave_value();
18830 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18831 if (SWIG_IsTmpObj(res1)) {
18832 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18833 } else {
18834 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18835 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18836 }
18837 if (SWIG_IsTmpObj(res2)) {
18838 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18839 } else {
18840 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18841 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18842 }
18843 return _out;
18844 fail:
18845 return octave_value_list();
18846 }
18847
18848
18849 SWIG_DEFUN( plgyax, _wrap_plgyax, _wrap_plgyax_texinfo ) {
18850 PLINT *arg1 = (PLINT *) 0 ;
18851 PLINT *arg2 = (PLINT *) 0 ;
18852 PLINT temp1 ;
18853 int res1 = SWIG_TMPOBJ ;
18854 PLINT temp2 ;
18855 int res2 = SWIG_TMPOBJ ;
18856 octave_value_list _out;
18857 octave_value_list *_outp=&_out;
18858 octave_value _outv;
18859
18860 arg1 = &temp1;
18861 arg2 = &temp2;
18862 if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
18863 SWIG_fail;
18864 }
18865 plgyax(arg1,arg2);
18866 _outv = octave_value();
18867 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18868 if (SWIG_IsTmpObj(res1)) {
18869 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18870 } else {
18871 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18872 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18873 }
18874 if (SWIG_IsTmpObj(res2)) {
18875 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18876 } else {
18877 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18878 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18879 }
18880 return _out;
18881 fail:
18882 return octave_value_list();
18883 }
18884
18885
18886 SWIG_DEFUN( plgzax, _wrap_plgzax, _wrap_plgzax_texinfo ) {
18887 PLINT *arg1 = (PLINT *) 0 ;
18888 PLINT *arg2 = (PLINT *) 0 ;
18889 PLINT temp1 ;
18890 int res1 = SWIG_TMPOBJ ;
18891 PLINT temp2 ;
18892 int res2 = SWIG_TMPOBJ ;
18893 octave_value_list _out;
18894 octave_value_list *_outp=&_out;
18895 octave_value _outv;
18896
18897 arg1 = &temp1;
18898 arg2 = &temp2;
18899 if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
18900 SWIG_fail;
18901 }
18902 plgzax(arg1,arg2);
18903 _outv = octave_value();
18904 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18905 if (SWIG_IsTmpObj(res1)) {
18906 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
18907 } else {
18908 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18909 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
18910 }
18911 if (SWIG_IsTmpObj(res2)) {
18912 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
18913 } else {
18914 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18915 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
18916 }
18917 return _out;
18918 fail:
18919 return octave_value_list();
18920 }
18921
18922
18923 SWIG_DEFUN( plhist, _wrap_plhist, _wrap_plhist_texinfo ) {
18924 PLINT arg1 ;
18925 PLFLT *arg2 = (PLFLT *) 0 ;
18926 PLFLT arg3 ;
18927 PLFLT arg4 ;
18928 PLINT arg5 ;
18929 PLINT arg6 ;
18930 Matrix temp1 ;
18931 double val3 ;
18932 int ecode3 = 0 ;
18933 double val4 ;
18934 int ecode4 = 0 ;
18935 int val5 ;
18936 int ecode5 = 0 ;
18937 int val6 ;
18938 int ecode6 = 0 ;
18939 octave_value_list _out;
18940 octave_value_list *_outp=&_out;
18941 octave_value _outv;
18942
18943 if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
18944 SWIG_fail;
18945 }
18946 {
18947 if ( _n_dims( args(0) ) > 1 )
18948 {
18949 error( "argument must be a scalar or vector" ); SWIG_fail;
18950 }
18951 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
18952 temp1 = args(0).matrix_value();
18953 arg2 = &temp1( 0, 0 );
18954 }
18955 ecode3 = SWIG_AsVal_double(args(1), &val3);
18956 if (!SWIG_IsOK(ecode3)) {
18957 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
18958 }
18959 arg3 = static_cast< PLFLT >(val3);
18960 ecode4 = SWIG_AsVal_double(args(2), &val4);
18961 if (!SWIG_IsOK(ecode4)) {
18962 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
18963 }
18964 arg4 = static_cast< PLFLT >(val4);
18965 ecode5 = SWIG_AsVal_int(args(3), &val5);
18966 if (!SWIG_IsOK(ecode5)) {
18967 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
18968 }
18969 arg5 = static_cast< PLINT >(val5);
18970 ecode6 = SWIG_AsVal_int(args(4), &val6);
18971 if (!SWIG_IsOK(ecode6)) {
18972 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
18973 }
18974 arg6 = static_cast< PLINT >(val6);
18975 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
18976 _outv = octave_value();
18977 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18978 {
18979
18980 }
18981 return _out;
18982 fail:
18983 {
18984
18985 }
18986 return octave_value_list();
18987 }
18988
18989
18990 SWIG_DEFUN( plhlsrgb, _wrap_plhlsrgb, _wrap_plhlsrgb_texinfo ) {
18991 PLFLT arg1 ;
18992 PLFLT arg2 ;
18993 PLFLT arg3 ;
18994 PLFLT *arg4 = (PLFLT *) 0 ;
18995 PLFLT *arg5 = (PLFLT *) 0 ;
18996 PLFLT *arg6 = (PLFLT *) 0 ;
18997 double val1 ;
18998 int ecode1 = 0 ;
18999 double val2 ;
19000 int ecode2 = 0 ;
19001 double val3 ;
19002 int ecode3 = 0 ;
19003 PLFLT temp4 ;
19004 int res4 = SWIG_TMPOBJ ;
19005 PLFLT temp5 ;
19006 int res5 = SWIG_TMPOBJ ;
19007 PLFLT temp6 ;
19008 int res6 = SWIG_TMPOBJ ;
19009 octave_value_list _out;
19010 octave_value_list *_outp=&_out;
19011 octave_value _outv;
19012
19013 arg4 = &temp4;
19014 arg5 = &temp5;
19015 arg6 = &temp6;
19016 if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
19017 SWIG_fail;
19018 }
19019 ecode1 = SWIG_AsVal_double(args(0), &val1);
19020 if (!SWIG_IsOK(ecode1)) {
19021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
19022 }
19023 arg1 = static_cast< PLFLT >(val1);
19024 ecode2 = SWIG_AsVal_double(args(1), &val2);
19025 if (!SWIG_IsOK(ecode2)) {
19026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
19027 }
19028 arg2 = static_cast< PLFLT >(val2);
19029 ecode3 = SWIG_AsVal_double(args(2), &val3);
19030 if (!SWIG_IsOK(ecode3)) {
19031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
19032 }
19033 arg3 = static_cast< PLFLT >(val3);
19034 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
19035 _outv = octave_value();
19036 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19037 if (SWIG_IsTmpObj(res4)) {
19038 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
19039 } else {
19040 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19041 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
19042 }
19043 if (SWIG_IsTmpObj(res5)) {
19044 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
19045 } else {
19046 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19047 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
19048 }
19049 if (SWIG_IsTmpObj(res6)) {
19050 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
19051 } else {
19052 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19053 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
19054 }
19055 return _out;
19056 fail:
19057 return octave_value_list();
19058 }
19059
19060
19061 SWIG_DEFUN( plinit, _wrap_plinit, _wrap_plinit_texinfo ) {
19062 octave_value_list _out;
19063 octave_value_list *_outp=&_out;
19064 octave_value _outv;
19065
19066 if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
19067 SWIG_fail;
19068 }
19069 plinit();
19070 _outv = octave_value();
19071 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19072 return _out;
19073 fail:
19074 return octave_value_list();
19075 }
19076
19077
19078 SWIG_DEFUN( pljoin, _wrap_pljoin, _wrap_pljoin_texinfo ) {
19079 PLFLT arg1 ;
19080 PLFLT arg2 ;
19081 PLFLT arg3 ;
19082 PLFLT arg4 ;
19083 double val1 ;
19084 int ecode1 = 0 ;
19085 double val2 ;
19086 int ecode2 = 0 ;
19087 double val3 ;
19088 int ecode3 = 0 ;
19089 double val4 ;
19090 int ecode4 = 0 ;
19091 octave_value_list _out;
19092 octave_value_list *_outp=&_out;
19093 octave_value _outv;
19094
19095 if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
19096 SWIG_fail;
19097 }
19098 ecode1 = SWIG_AsVal_double(args(0), &val1);
19099 if (!SWIG_IsOK(ecode1)) {
19100 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
19101 }
19102 arg1 = static_cast< PLFLT >(val1);
19103 ecode2 = SWIG_AsVal_double(args(1), &val2);
19104 if (!SWIG_IsOK(ecode2)) {
19105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
19106 }
19107 arg2 = static_cast< PLFLT >(val2);
19108 ecode3 = SWIG_AsVal_double(args(2), &val3);
19109 if (!SWIG_IsOK(ecode3)) {
19110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
19111 }
19112 arg3 = static_cast< PLFLT >(val3);
19113 ecode4 = SWIG_AsVal_double(args(3), &val4);
19114 if (!SWIG_IsOK(ecode4)) {
19115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
19116 }
19117 arg4 = static_cast< PLFLT >(val4);
19118 pljoin(arg1,arg2,arg3,arg4);
19119 _outv = octave_value();
19120 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19121 return _out;
19122 fail:
19123 return octave_value_list();
19124 }
19125
19126
19127 SWIG_DEFUN( pllab, _wrap_pllab, _wrap_pllab_texinfo ) {
19128 char *arg1 = (char *) 0 ;
19129 char *arg2 = (char *) 0 ;
19130 char *arg3 = (char *) 0 ;
19131 int res1 ;
19132 char *buf1 = 0 ;
19133 int alloc1 = 0 ;
19134 int res2 ;
19135 char *buf2 = 0 ;
19136 int alloc2 = 0 ;
19137 int res3 ;
19138 char *buf3 = 0 ;
19139 int alloc3 = 0 ;
19140 octave_value_list _out;
19141 octave_value_list *_outp=&_out;
19142 octave_value _outv;
19143
19144 if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
19145 SWIG_fail;
19146 }
19147 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19148 if (!SWIG_IsOK(res1)) {
19149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
19150 }
19151 arg1 = reinterpret_cast< char * >(buf1);
19152 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
19153 if (!SWIG_IsOK(res2)) {
19154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
19155 }
19156 arg2 = reinterpret_cast< char * >(buf2);
19157 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
19158 if (!SWIG_IsOK(res3)) {
19159 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
19160 }
19161 arg3 = reinterpret_cast< char * >(buf3);
19162 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
19163 _outv = octave_value();
19164 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19165 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19166 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19167 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19168 return _out;
19169 fail:
19170 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19171 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
19172 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
19173 return octave_value_list();
19174 }
19175
19176
19177 SWIG_DEFUN( pllegend, _wrap_pllegend, _wrap_pllegend_texinfo ) {
19178 PLFLT *arg1 = (PLFLT *) 0 ;
19179 PLFLT *arg2 = (PLFLT *) 0 ;
19180 PLINT arg3 ;
19181 PLINT arg4 ;
19182 PLFLT arg5 ;
19183 PLFLT arg6 ;
19184 PLFLT arg7 ;
19185 PLINT arg8 ;
19186 PLINT arg9 ;
19187 PLINT arg10 ;
19188 PLINT arg11 ;
19189 PLINT arg12 ;
19190 PLINT arg13 ;
19191 PLINT *arg14 = (PLINT *) 0 ;
19192 PLFLT arg15 ;
19193 PLFLT arg16 ;
19194 PLFLT arg17 ;
19195 PLFLT arg18 ;
19196 PLINT *arg19 = (PLINT *) 0 ;
19197 char **arg20 = (char **) 0 ;
19198 PLINT *arg21 = (PLINT *) 0 ;
19199 PLINT *arg22 = (PLINT *) 0 ;
19200 PLFLT *arg23 = (PLFLT *) 0 ;
19201 PLFLT *arg24 = (PLFLT *) 0 ;
19202 PLINT *arg25 = (PLINT *) 0 ;
19203 PLINT *arg26 = (PLINT *) 0 ;
19204 PLFLT *arg27 = (PLFLT *) 0 ;
19205 PLINT *arg28 = (PLINT *) 0 ;
19206 PLFLT *arg29 = (PLFLT *) 0 ;
19207 PLINT *arg30 = (PLINT *) 0 ;
19208 char **arg31 = (char **) 0 ;
19209 PLFLT temp1 ;
19210 int res1 = SWIG_TMPOBJ ;
19211 PLFLT temp2 ;
19212 int res2 = SWIG_TMPOBJ ;
19213 int val3 ;
19214 int ecode3 = 0 ;
19215 int val4 ;
19216 int ecode4 = 0 ;
19217 double val5 ;
19218 int ecode5 = 0 ;
19219 double val6 ;
19220 int ecode6 = 0 ;
19221 double val7 ;
19222 int ecode7 = 0 ;
19223 int val8 ;
19224 int ecode8 = 0 ;
19225 int val9 ;
19226 int ecode9 = 0 ;
19227 int val10 ;
19228 int ecode10 = 0 ;
19229 int val11 ;
19230 int ecode11 = 0 ;
19231 int val12 ;
19232 int ecode12 = 0 ;
19233 Matrix temp13 ;
19234 double val15 ;
19235 int ecode15 = 0 ;
19236 double val16 ;
19237 int ecode16 = 0 ;
19238 double val17 ;
19239 int ecode17 = 0 ;
19240 double val18 ;
19241 int ecode18 = 0 ;
19242 Matrix temp19 ;
19243 Matrix temp21 ;
19244 Matrix temp22 ;
19245 Matrix temp23 ;
19246 Matrix temp24 ;
19247 Matrix temp25 ;
19248 Matrix temp26 ;
19249 Matrix temp27 ;
19250 Matrix temp28 ;
19251 Matrix temp29 ;
19252 Matrix temp30 ;
19253 octave_value_list _out;
19254 octave_value_list *_outp=&_out;
19255 octave_value _outv;
19256
19257 arg1 = &temp1;
19258 arg2 = &temp2;
19259 if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
19260 SWIG_fail;
19261 }
19262 ecode3 = SWIG_AsVal_int(args(0), &val3);
19263 if (!SWIG_IsOK(ecode3)) {
19264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
19265 }
19266 arg3 = static_cast< PLINT >(val3);
19267 ecode4 = SWIG_AsVal_int(args(1), &val4);
19268 if (!SWIG_IsOK(ecode4)) {
19269 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
19270 }
19271 arg4 = static_cast< PLINT >(val4);
19272 ecode5 = SWIG_AsVal_double(args(2), &val5);
19273 if (!SWIG_IsOK(ecode5)) {
19274 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
19275 }
19276 arg5 = static_cast< PLFLT >(val5);
19277 ecode6 = SWIG_AsVal_double(args(3), &val6);
19278 if (!SWIG_IsOK(ecode6)) {
19279 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
19280 }
19281 arg6 = static_cast< PLFLT >(val6);
19282 ecode7 = SWIG_AsVal_double(args(4), &val7);
19283 if (!SWIG_IsOK(ecode7)) {
19284 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
19285 }
19286 arg7 = static_cast< PLFLT >(val7);
19287 ecode8 = SWIG_AsVal_int(args(5), &val8);
19288 if (!SWIG_IsOK(ecode8)) {
19289 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
19290 }
19291 arg8 = static_cast< PLINT >(val8);
19292 ecode9 = SWIG_AsVal_int(args(6), &val9);
19293 if (!SWIG_IsOK(ecode9)) {
19294 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
19295 }
19296 arg9 = static_cast< PLINT >(val9);
19297 ecode10 = SWIG_AsVal_int(args(7), &val10);
19298 if (!SWIG_IsOK(ecode10)) {
19299 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
19300 }
19301 arg10 = static_cast< PLINT >(val10);
19302 ecode11 = SWIG_AsVal_int(args(8), &val11);
19303 if (!SWIG_IsOK(ecode11)) {
19304 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
19305 }
19306 arg11 = static_cast< PLINT >(val11);
19307 ecode12 = SWIG_AsVal_int(args(9), &val12);
19308 if (!SWIG_IsOK(ecode12)) {
19309 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
19310 }
19311 arg12 = static_cast< PLINT >(val12);
19312 {
19313 if ( _n_dims( args(10) ) > 1 )
19314 {
19315 error( "argument must be a scalar or vector" ); SWIG_fail;
19316 }
19317 arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
19318 arg14 = new PLINT[Alen];
19319 temp13 = args(10).matrix_value();
19320 _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
19321 }
19322 ecode15 = SWIG_AsVal_double(args(11), &val15);
19323 if (!SWIG_IsOK(ecode15)) {
19324 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
19325 }
19326 arg15 = static_cast< PLFLT >(val15);
19327 ecode16 = SWIG_AsVal_double(args(12), &val16);
19328 if (!SWIG_IsOK(ecode16)) {
19329 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
19330 }
19331 arg16 = static_cast< PLFLT >(val16);
19332 ecode17 = SWIG_AsVal_double(args(13), &val17);
19333 if (!SWIG_IsOK(ecode17)) {
19334 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
19335 }
19336 arg17 = static_cast< PLFLT >(val17);
19337 ecode18 = SWIG_AsVal_double(args(14), &val18);
19338 if (!SWIG_IsOK(ecode18)) {
19339 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
19340 }
19341 arg18 = static_cast< PLFLT >(val18);
19342 {
19343 if ( _n_dims( args(15) ) > 1 )
19344 {
19345 error( "argument must be a scalar or vector" ); SWIG_fail;
19346 }
19347 if ( _dim( args(15), 0 ) != Alen )
19348 {
19349 error( "argument vectors must be same length" ); SWIG_fail;
19350 }
19351 temp19 = args(15).matrix_value();
19352 arg19 = new PLINT[Alen];
19353 _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
19354 }
19355 {
19356 charMatrix temp_matrix;
19357 Cell temp_cell;
19358 char *tmp_cstring;
19359 std::string str;
19360 size_t max_length = 0, non_blank_length;
19361 int i, ifcell;
19362 if ( _n_dims( args(16) ) > 2 )
19363 {
19364 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
19365 }
19366 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19367 if ( !args(16).isempty() )
19368 #else
19369 if ( !args(16).is_empty() )
19370 #endif
19371 {
19372 if ( _dim( args(16), 0 ) != Alen )
19373 {
19374 error( "first dimension must be same length as previous vector" ); SWIG_fail;
19375 }
19376 arg20 = new char*[Alen];
19377 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19378 ifcell = args(16).iscell();
19379 #else
19380 ifcell = args(16).is_cell();
19381 #endif
19382 if ( ifcell )
19383 {
19384 temp_cell = args(16).cell_value();
19385 }
19386 else
19387 {
19388 temp_matrix = args(16).char_matrix_value();
19389 // Allow one extra space for null termination.
19390 max_length = _dim( args(16), 1 ) + 1;
19391 }
19392
19393 for ( i = 0; i < Alen; i++ )
19394 {
19395 // Must copy string to "permanent" location because the string
19396 // location corresponding to tmp_cstring gets
19397 // overwritten for each iteration of loop.
19398 if ( ifcell )
19399 {
19400 if ( temp_cell.elem( i ).is_string() )
19401 {
19402 str = temp_cell.elem( i ).string_value();
19403 // leave room for null termination.
19404 max_length = str.size() + 1;
19405 tmp_cstring = (char *) str.c_str();
19406 }
19407 else
19408 {
19409 // Use null string if user attempts to pass a cell array
19410 // with a non-string element (likely an empty element
19411 // since that should be allowed by the PLplot interface
19412 // if that element is going to be unused).
19413 // leave room for null termination.
19414 max_length = 1;
19415 tmp_cstring = (char *) "";
19416 }
19417 }
19418 else
19419 {
19420 str = temp_matrix.row_as_string( i );
19421 tmp_cstring = (char *) str.c_str();
19422 }
19423 arg20[i] = new char[max_length];
19424 strncpy( arg20[i], tmp_cstring, max_length - 1 );
19425 arg20[i][max_length - 1] = '\0';
19426 // All the trailing blank crapola should not be needed for
19427 // string cell arrays.
19428 if ( !ifcell )
19429 {
19430 // remove trailing-blank padding that is used by the
19431 // charMatrix class to insure all strings in a given
19432 // charMatrix instance have the same length.
19433 // This transformation also removes legitimate trailing
19434 // blanks but there is nothing we can do about that
19435 // for the charMatrix class.
19436
19437 // Look for trailing nulls first (just in case, although that
19438 // shouldn't happen if charMatrix implemented as documented)
19439 // before looking for trailing blanks.
19440 non_blank_length = max_length - 2;
19441 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
19442 {
19443 non_blank_length--;
19444 }
19445 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
19446 {
19447 non_blank_length--;
19448 }
19449 arg20[i][non_blank_length + 1] = '\0';
19450 }
19451 }
19452 }
19453 else
19454 {
19455 arg20 = NULL;
19456 }
19457 }
19458 {
19459 if ( _n_dims( args(17) ) > 1 )
19460 {
19461 error( "argument must be a scalar or vector" ); SWIG_fail;
19462 }
19463 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19464 if ( !args(17).isempty() )
19465 #else
19466 if ( !args(17).is_empty() )
19467 #endif
19468 {
19469 if ( _dim( args(17), 0 ) != Alen )
19470 {
19471 error( "argument vectors must be same length" ); SWIG_fail;
19472 }
19473 temp21 = args(17).matrix_value();
19474 arg21 = new PLINT[Alen];
19475 _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
19476 }
19477 else
19478 {
19479 arg21 = NULL;
19480 }
19481 }
19482 {
19483 if ( _n_dims( args(18) ) > 1 )
19484 {
19485 error( "argument must be a scalar or vector" ); SWIG_fail;
19486 }
19487 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19488 if ( !args(18).isempty() )
19489 #else
19490 if ( !args(18).is_empty() )
19491 #endif
19492 {
19493 if ( _dim( args(18), 0 ) != Alen )
19494 {
19495 error( "argument vectors must be same length" ); SWIG_fail;
19496 }
19497 temp22 = args(18).matrix_value();
19498 arg22 = new PLINT[Alen];
19499 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
19500 }
19501 else
19502 {
19503 arg22 = NULL;
19504 }
19505 }
19506 {
19507 if ( _n_dims( args(19) ) > 1 )
19508 {
19509 error( "argument must be a scalar or vector" ); SWIG_fail;
19510 }
19511 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19512 if ( !args(19).isempty() )
19513 #else
19514 if ( !args(19).is_empty() )
19515 #endif
19516 {
19517 if ( _dim( args(19), 0 ) != Alen )
19518 {
19519 error( "argument vectors must be same length" ); SWIG_fail;
19520 }
19521 temp23 = args(19).matrix_value();
19522 arg23 = &temp23( 0, 0 );
19523 }
19524 else
19525 {
19526 arg23 = NULL;
19527 }
19528 }
19529 {
19530 if ( _n_dims( args(20) ) > 1 )
19531 {
19532 error( "argument must be a scalar or vector" ); SWIG_fail;
19533 }
19534 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19535 if ( !args(20).isempty() )
19536 #else
19537 if ( !args(20).is_empty() )
19538 #endif
19539 {
19540 if ( _dim( args(20), 0 ) != Alen )
19541 {
19542 error( "argument vectors must be same length" ); SWIG_fail;
19543 }
19544 temp24 = args(20).matrix_value();
19545 arg24 = &temp24( 0, 0 );
19546 }
19547 else
19548 {
19549 arg24 = NULL;
19550 }
19551 }
19552 {
19553 if ( _n_dims( args(21) ) > 1 )
19554 {
19555 error( "argument must be a scalar or vector" ); SWIG_fail;
19556 }
19557 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19558 if ( !args(21).isempty() )
19559 #else
19560 if ( !args(21).is_empty() )
19561 #endif
19562 {
19563 if ( _dim( args(21), 0 ) != Alen )
19564 {
19565 error( "argument vectors must be same length" ); SWIG_fail;
19566 }
19567 temp25 = args(21).matrix_value();
19568 arg25 = new PLINT[Alen];
19569 _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
19570 }
19571 else
19572 {
19573 arg25 = NULL;
19574 }
19575 }
19576 {
19577 if ( _n_dims( args(22) ) > 1 )
19578 {
19579 error( "argument must be a scalar or vector" ); SWIG_fail;
19580 }
19581 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19582 if ( !args(22).isempty() )
19583 #else
19584 if ( !args(22).is_empty() )
19585 #endif
19586 {
19587 if ( _dim( args(22), 0 ) != Alen )
19588 {
19589 error( "argument vectors must be same length" ); SWIG_fail;
19590 }
19591 temp26 = args(22).matrix_value();
19592 arg26 = new PLINT[Alen];
19593 _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
19594 }
19595 else
19596 {
19597 arg26 = NULL;
19598 }
19599 }
19600 {
19601 if ( _n_dims( args(23) ) > 1 )
19602 {
19603 error( "argument must be a scalar or vector" ); SWIG_fail;
19604 }
19605 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19606 if ( !args(23).isempty() )
19607 #else
19608 if ( !args(23).is_empty() )
19609 #endif
19610 {
19611 if ( _dim( args(23), 0 ) != Alen )
19612 {
19613 error( "argument vectors must be same length" ); SWIG_fail;
19614 }
19615 temp27 = args(23).matrix_value();
19616 arg27 = &temp27( 0, 0 );
19617 }
19618 else
19619 {
19620 arg27 = NULL;
19621 }
19622 }
19623 {
19624 if ( _n_dims( args(24) ) > 1 )
19625 {
19626 error( "argument must be a scalar or vector" ); SWIG_fail;
19627 }
19628 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19629 if ( !args(24).isempty() )
19630 #else
19631 if ( !args(24).is_empty() )
19632 #endif
19633 {
19634 if ( _dim( args(24), 0 ) != Alen )
19635 {
19636 error( "argument vectors must be same length" ); SWIG_fail;
19637 }
19638 temp28 = args(24).matrix_value();
19639 arg28 = new PLINT[Alen];
19640 _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
19641 }
19642 else
19643 {
19644 arg28 = NULL;
19645 }
19646 }
19647 {
19648 if ( _n_dims( args(25) ) > 1 )
19649 {
19650 error( "argument must be a scalar or vector" ); SWIG_fail;
19651 }
19652 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19653 if ( !args(25).isempty() )
19654 #else
19655 if ( !args(25).is_empty() )
19656 #endif
19657 {
19658 if ( _dim( args(25), 0 ) != Alen )
19659 {
19660 error( "argument vectors must be same length" ); SWIG_fail;
19661 }
19662 temp29 = args(25).matrix_value();
19663 arg29 = &temp29( 0, 0 );
19664 }
19665 else
19666 {
19667 arg29 = NULL;
19668 }
19669 }
19670 {
19671 if ( _n_dims( args(26) ) > 1 )
19672 {
19673 error( "argument must be a scalar or vector" ); SWIG_fail;
19674 }
19675 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19676 if ( !args(26).isempty() )
19677 #else
19678 if ( !args(26).is_empty() )
19679 #endif
19680 {
19681 if ( _dim( args(26), 0 ) != Alen )
19682 {
19683 error( "argument vectors must be same length" ); SWIG_fail;
19684 }
19685 temp30 = args(26).matrix_value();
19686 arg30 = new PLINT[Alen];
19687 _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
19688 }
19689 else
19690 {
19691 arg30 = NULL;
19692 }
19693 }
19694 {
19695 charMatrix temp_matrix;
19696 Cell temp_cell;
19697 char *tmp_cstring;
19698 std::string str;
19699 size_t max_length = 0, non_blank_length;
19700 int i, ifcell;
19701 if ( _n_dims( args(27) ) > 2 )
19702 {
19703 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
19704 }
19705 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19706 if ( !args(27).isempty() )
19707 #else
19708 if ( !args(27).is_empty() )
19709 #endif
19710 {
19711 if ( _dim( args(27), 0 ) != Alen )
19712 {
19713 error( "first dimension must be same length as previous vector" ); SWIG_fail;
19714 }
19715 arg31 = new char*[Alen];
19716 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
19717 ifcell = args(27).iscell();
19718 #else
19719 ifcell = args(27).is_cell();
19720 #endif
19721 if ( ifcell )
19722 {
19723 temp_cell = args(27).cell_value();
19724 }
19725 else
19726 {
19727 temp_matrix = args(27).char_matrix_value();
19728 // Allow one extra space for null termination.
19729 max_length = _dim( args(27), 1 ) + 1;
19730 }
19731
19732 for ( i = 0; i < Alen; i++ )
19733 {
19734 // Must copy string to "permanent" location because the string
19735 // location corresponding to tmp_cstring gets
19736 // overwritten for each iteration of loop.
19737 if ( ifcell )
19738 {
19739 if ( temp_cell.elem( i ).is_string() )
19740 {
19741 str = temp_cell.elem( i ).string_value();
19742 // leave room for null termination.
19743 max_length = str.size() + 1;
19744 tmp_cstring = (char *) str.c_str();
19745 }
19746 else
19747 {
19748 // Use null string if user attempts to pass a cell array
19749 // with a non-string element (likely an empty element
19750 // since that should be allowed by the PLplot interface
19751 // if that element is going to be unused).
19752 // leave room for null termination.
19753 max_length = 1;
19754 tmp_cstring = (char *) "";
19755 }
19756 }
19757 else
19758 {
19759 str = temp_matrix.row_as_string( i );
19760 tmp_cstring = (char *) str.c_str();
19761 }
19762 arg31[i] = new char[max_length];
19763 strncpy( arg31[i], tmp_cstring, max_length - 1 );
19764 arg31[i][max_length - 1] = '\0';
19765 // All the trailing blank crapola should not be needed for
19766 // string cell arrays.
19767 if ( !ifcell )
19768 {
19769 // remove trailing-blank padding that is used by the
19770 // charMatrix class to insure all strings in a given
19771 // charMatrix instance have the same length.
19772 // This transformation also removes legitimate trailing
19773 // blanks but there is nothing we can do about that
19774 // for the charMatrix class.
19775
19776 // Look for trailing nulls first (just in case, although that
19777 // shouldn't happen if charMatrix implemented as documented)
19778 // before looking for trailing blanks.
19779 non_blank_length = max_length - 2;
19780 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
19781 {
19782 non_blank_length--;
19783 }
19784 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
19785 {
19786 non_blank_length--;
19787 }
19788 arg31[i][non_blank_length + 1] = '\0';
19789 }
19790 }
19791 }
19792 else
19793 {
19794 arg31 = NULL;
19795 }
19796 }
19797 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);
19798 _outv = octave_value();
19799 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19800 if (SWIG_IsTmpObj(res1)) {
19801 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
19802 } else {
19803 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19804 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
19805 }
19806 if (SWIG_IsTmpObj(res2)) {
19807 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
19808 } else {
19809 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19810 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
19811 }
19812 {
19813 delete [] arg14;
19814 }
19815 {
19816 delete [] arg19;
19817 }
19818 {
19819 int i;
19820 if ( arg20 != NULL )
19821 {
19822 for ( i = 0; i < Alen; i++ )
19823 {
19824 delete[] arg20[i];
19825 }
19826 delete[] arg20;
19827 }
19828 }
19829 {
19830 if ( arg21 != NULL )
19831 delete [] arg21;
19832 }
19833 {
19834 if ( arg22 != NULL )
19835 delete [] arg22;
19836 }
19837 {
19838
19839 }
19840 {
19841
19842 }
19843 {
19844 if ( arg25 != NULL )
19845 delete [] arg25;
19846 }
19847 {
19848 if ( arg26 != NULL )
19849 delete [] arg26;
19850 }
19851 {
19852
19853 }
19854 {
19855 if ( arg28 != NULL )
19856 delete [] arg28;
19857 }
19858 {
19859
19860 }
19861 {
19862 if ( arg30 != NULL )
19863 delete [] arg30;
19864 }
19865 {
19866 int i;
19867 if ( arg31 != NULL )
19868 {
19869 for ( i = 0; i < Alen; i++ )
19870 {
19871 delete[] arg31[i];
19872 }
19873 delete[] arg31;
19874 }
19875 }
19876 return _out;
19877 fail:
19878 {
19879 delete [] arg14;
19880 }
19881 {
19882 delete [] arg19;
19883 }
19884 {
19885 int i;
19886 if ( arg20 != NULL )
19887 {
19888 for ( i = 0; i < Alen; i++ )
19889 {
19890 delete[] arg20[i];
19891 }
19892 delete[] arg20;
19893 }
19894 }
19895 {
19896 if ( arg21 != NULL )
19897 delete [] arg21;
19898 }
19899 {
19900 if ( arg22 != NULL )
19901 delete [] arg22;
19902 }
19903 {
19904
19905 }
19906 {
19907
19908 }
19909 {
19910 if ( arg25 != NULL )
19911 delete [] arg25;
19912 }
19913 {
19914 if ( arg26 != NULL )
19915 delete [] arg26;
19916 }
19917 {
19918
19919 }
19920 {
19921 if ( arg28 != NULL )
19922 delete [] arg28;
19923 }
19924 {
19925
19926 }
19927 {
19928 if ( arg30 != NULL )
19929 delete [] arg30;
19930 }
19931 {
19932 int i;
19933 if ( arg31 != NULL )
19934 {
19935 for ( i = 0; i < Alen; i++ )
19936 {
19937 delete[] arg31[i];
19938 }
19939 delete[] arg31;
19940 }
19941 }
19942 return octave_value_list();
19943 }
19944
19945
19946 SWIG_DEFUN( pllightsource, _wrap_pllightsource, _wrap_pllightsource_texinfo ) {
19947 PLFLT arg1 ;
19948 PLFLT arg2 ;
19949 PLFLT arg3 ;
19950 double val1 ;
19951 int ecode1 = 0 ;
19952 double val2 ;
19953 int ecode2 = 0 ;
19954 double val3 ;
19955 int ecode3 = 0 ;
19956 octave_value_list _out;
19957 octave_value_list *_outp=&_out;
19958 octave_value _outv;
19959
19960 if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
19961 SWIG_fail;
19962 }
19963 ecode1 = SWIG_AsVal_double(args(0), &val1);
19964 if (!SWIG_IsOK(ecode1)) {
19965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
19966 }
19967 arg1 = static_cast< PLFLT >(val1);
19968 ecode2 = SWIG_AsVal_double(args(1), &val2);
19969 if (!SWIG_IsOK(ecode2)) {
19970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
19971 }
19972 arg2 = static_cast< PLFLT >(val2);
19973 ecode3 = SWIG_AsVal_double(args(2), &val3);
19974 if (!SWIG_IsOK(ecode3)) {
19975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
19976 }
19977 arg3 = static_cast< PLFLT >(val3);
19978 pllightsource(arg1,arg2,arg3);
19979 _outv = octave_value();
19980 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19981 return _out;
19982 fail:
19983 return octave_value_list();
19984 }
19985
19986
19987 SWIG_DEFUN( plline, _wrap_plline, _wrap_plline_texinfo ) {
19988 PLINT arg1 ;
19989 PLFLT *arg2 = (PLFLT *) 0 ;
19990 PLFLT *arg3 = (PLFLT *) 0 ;
19991 Matrix temp1 ;
19992 Matrix temp3 ;
19993 octave_value_list _out;
19994 octave_value_list *_outp=&_out;
19995 octave_value _outv;
19996
19997 if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
19998 SWIG_fail;
19999 }
20000 {
20001 if ( _n_dims( args(0) ) > 1 )
20002 {
20003 error( "argument must be a scalar or vector" ); SWIG_fail;
20004 }
20005 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20006 temp1 = args(0).matrix_value();
20007 arg2 = &temp1( 0, 0 );
20008 }
20009 {
20010 if ( _n_dims( args(1) ) > 1 )
20011 {
20012 error( "argument must be a scalar or vector" ); SWIG_fail;
20013 }
20014 if ( _dim( args(1), 0 ) != Alen )
20015 {
20016 error( "argument vectors must be same length" ); SWIG_fail;
20017 }
20018 temp3 = args(1).matrix_value();
20019 arg3 = &temp3( 0, 0 );
20020 }
20021 plline(arg1,(double const *)arg2,(double const *)arg3);
20022 _outv = octave_value();
20023 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20024 {
20025
20026 }
20027 {
20028
20029 }
20030 return _out;
20031 fail:
20032 {
20033
20034 }
20035 {
20036
20037 }
20038 return octave_value_list();
20039 }
20040
20041
20042 SWIG_DEFUN( plline3, _wrap_plline3, _wrap_plline3_texinfo ) {
20043 PLINT arg1 ;
20044 PLFLT *arg2 = (PLFLT *) 0 ;
20045 PLFLT *arg3 = (PLFLT *) 0 ;
20046 PLFLT *arg4 = (PLFLT *) 0 ;
20047 Matrix temp1 ;
20048 Matrix temp3 ;
20049 Matrix temp4 ;
20050 octave_value_list _out;
20051 octave_value_list *_outp=&_out;
20052 octave_value _outv;
20053
20054 if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
20055 SWIG_fail;
20056 }
20057 {
20058 if ( _n_dims( args(0) ) > 1 )
20059 {
20060 error( "argument must be a scalar or vector" ); SWIG_fail;
20061 }
20062 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20063 temp1 = args(0).matrix_value();
20064 arg2 = &temp1( 0, 0 );
20065 }
20066 {
20067 if ( _n_dims( args(1) ) > 1 )
20068 {
20069 error( "argument must be a scalar or vector" ); SWIG_fail;
20070 }
20071 if ( _dim( args(1), 0 ) != Alen )
20072 {
20073 error( "argument vectors must be same length" ); SWIG_fail;
20074 }
20075 temp3 = args(1).matrix_value();
20076 arg3 = &temp3( 0, 0 );
20077 }
20078 {
20079 if ( _n_dims( args(2) ) > 1 )
20080 {
20081 error( "argument must be a scalar or vector" ); SWIG_fail;
20082 }
20083 if ( _dim( args(2), 0 ) != Alen )
20084 {
20085 error( "argument vectors must be same length" ); SWIG_fail;
20086 }
20087 temp4 = args(2).matrix_value();
20088 arg4 = &temp4( 0, 0 );
20089 }
20090 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
20091 _outv = octave_value();
20092 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20093 {
20094
20095 }
20096 {
20097
20098 }
20099 {
20100
20101 }
20102 return _out;
20103 fail:
20104 {
20105
20106 }
20107 {
20108
20109 }
20110 {
20111
20112 }
20113 return octave_value_list();
20114 }
20115
20116
20117 SWIG_DEFUN( pllsty, _wrap_pllsty, _wrap_pllsty_texinfo ) {
20118 PLINT arg1 ;
20119 int val1 ;
20120 int ecode1 = 0 ;
20121 octave_value_list _out;
20122 octave_value_list *_outp=&_out;
20123 octave_value _outv;
20124
20125 if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
20126 SWIG_fail;
20127 }
20128 ecode1 = SWIG_AsVal_int(args(0), &val1);
20129 if (!SWIG_IsOK(ecode1)) {
20130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
20131 }
20132 arg1 = static_cast< PLINT >(val1);
20133 pllsty(arg1);
20134 _outv = octave_value();
20135 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20136 return _out;
20137 fail:
20138 return octave_value_list();
20139 }
20140
20141
20142 SWIG_DEFUN( plmkstrm, _wrap_plmkstrm, _wrap_plmkstrm_texinfo ) {
20143 PLINT *arg1 = (PLINT *) 0 ;
20144 PLINT temp1 ;
20145 int res1 = SWIG_TMPOBJ ;
20146 octave_value_list _out;
20147 octave_value_list *_outp=&_out;
20148 octave_value _outv;
20149
20150 arg1 = &temp1;
20151 if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
20152 SWIG_fail;
20153 }
20154 plmkstrm(arg1);
20155 _outv = octave_value();
20156 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20157 if (SWIG_IsTmpObj(res1)) {
20158 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
20159 } else {
20160 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20161 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
20162 }
20163 return _out;
20164 fail:
20165 return octave_value_list();
20166 }
20167
20168
20169 SWIG_DEFUN( plmtex, _wrap_plmtex, _wrap_plmtex_texinfo ) {
20170 char *arg1 = (char *) 0 ;
20171 PLFLT arg2 ;
20172 PLFLT arg3 ;
20173 PLFLT arg4 ;
20174 char *arg5 = (char *) 0 ;
20175 int res1 ;
20176 char *buf1 = 0 ;
20177 int alloc1 = 0 ;
20178 double val2 ;
20179 int ecode2 = 0 ;
20180 double val3 ;
20181 int ecode3 = 0 ;
20182 double val4 ;
20183 int ecode4 = 0 ;
20184 int res5 ;
20185 char *buf5 = 0 ;
20186 int alloc5 = 0 ;
20187 octave_value_list _out;
20188 octave_value_list *_outp=&_out;
20189 octave_value _outv;
20190
20191 if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
20192 SWIG_fail;
20193 }
20194 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20195 if (!SWIG_IsOK(res1)) {
20196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
20197 }
20198 arg1 = reinterpret_cast< char * >(buf1);
20199 ecode2 = SWIG_AsVal_double(args(1), &val2);
20200 if (!SWIG_IsOK(ecode2)) {
20201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
20202 }
20203 arg2 = static_cast< PLFLT >(val2);
20204 ecode3 = SWIG_AsVal_double(args(2), &val3);
20205 if (!SWIG_IsOK(ecode3)) {
20206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
20207 }
20208 arg3 = static_cast< PLFLT >(val3);
20209 ecode4 = SWIG_AsVal_double(args(3), &val4);
20210 if (!SWIG_IsOK(ecode4)) {
20211 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
20212 }
20213 arg4 = static_cast< PLFLT >(val4);
20214 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
20215 if (!SWIG_IsOK(res5)) {
20216 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
20217 }
20218 arg5 = reinterpret_cast< char * >(buf5);
20219 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
20220 _outv = octave_value();
20221 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20222 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20223 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20224 return _out;
20225 fail:
20226 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20227 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20228 return octave_value_list();
20229 }
20230
20231
20232 SWIG_DEFUN( plmtex3, _wrap_plmtex3, _wrap_plmtex3_texinfo ) {
20233 char *arg1 = (char *) 0 ;
20234 PLFLT arg2 ;
20235 PLFLT arg3 ;
20236 PLFLT arg4 ;
20237 char *arg5 = (char *) 0 ;
20238 int res1 ;
20239 char *buf1 = 0 ;
20240 int alloc1 = 0 ;
20241 double val2 ;
20242 int ecode2 = 0 ;
20243 double val3 ;
20244 int ecode3 = 0 ;
20245 double val4 ;
20246 int ecode4 = 0 ;
20247 int res5 ;
20248 char *buf5 = 0 ;
20249 int alloc5 = 0 ;
20250 octave_value_list _out;
20251 octave_value_list *_outp=&_out;
20252 octave_value _outv;
20253
20254 if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
20255 SWIG_fail;
20256 }
20257 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20258 if (!SWIG_IsOK(res1)) {
20259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
20260 }
20261 arg1 = reinterpret_cast< char * >(buf1);
20262 ecode2 = SWIG_AsVal_double(args(1), &val2);
20263 if (!SWIG_IsOK(ecode2)) {
20264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
20265 }
20266 arg2 = static_cast< PLFLT >(val2);
20267 ecode3 = SWIG_AsVal_double(args(2), &val3);
20268 if (!SWIG_IsOK(ecode3)) {
20269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
20270 }
20271 arg3 = static_cast< PLFLT >(val3);
20272 ecode4 = SWIG_AsVal_double(args(3), &val4);
20273 if (!SWIG_IsOK(ecode4)) {
20274 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
20275 }
20276 arg4 = static_cast< PLFLT >(val4);
20277 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
20278 if (!SWIG_IsOK(res5)) {
20279 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
20280 }
20281 arg5 = reinterpret_cast< char * >(buf5);
20282 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
20283 _outv = octave_value();
20284 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20285 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20286 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20287 return _out;
20288 fail:
20289 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20290 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
20291 return octave_value_list();
20292 }
20293
20294
20295 SWIG_DEFUN( plparseopts, _wrap_plparseopts, _wrap_plparseopts_texinfo ) {
20296 int *arg1 = (int *) 0 ;
20297 char **arg2 = (char **) 0 ;
20298 PLINT arg3 ;
20299 void *argp1 = 0 ;
20300 int res1 = 0 ;
20301 void *argp2 = 0 ;
20302 int res2 = 0 ;
20303 int val3 ;
20304 int ecode3 = 0 ;
20305 octave_value_list _out;
20306 octave_value_list *_outp=&_out;
20307 octave_value _outv;
20308 PLINT result;
20309
20310 if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
20311 SWIG_fail;
20312 }
20313 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
20314 if (!SWIG_IsOK(res1)) {
20315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
20316 }
20317 arg1 = reinterpret_cast< int * >(argp1);
20318 res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
20319 if (!SWIG_IsOK(res2)) {
20320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char **""'");
20321 }
20322 arg2 = reinterpret_cast< char ** >(argp2);
20323 ecode3 = SWIG_AsVal_int(args(2), &val3);
20324 if (!SWIG_IsOK(ecode3)) {
20325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
20326 }
20327 arg3 = static_cast< PLINT >(val3);
20328 result = (PLINT)plparseopts(arg1,arg2,arg3);
20329 _outv = SWIG_From_int(static_cast< int >(result));
20330 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20331 return _out;
20332 fail:
20333 return octave_value_list();
20334 }
20335
20336
20337 SWIG_DEFUN( plpat, _wrap_plpat, _wrap_plpat_texinfo ) {
20338 PLINT arg1 ;
20339 PLINT *arg2 = (PLINT *) 0 ;
20340 PLINT *arg3 = (PLINT *) 0 ;
20341 Matrix temp1 ;
20342 Matrix temp3 ;
20343 octave_value_list _out;
20344 octave_value_list *_outp=&_out;
20345 octave_value _outv;
20346
20347 if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
20348 SWIG_fail;
20349 }
20350 {
20351 if ( _n_dims( args(0) ) > 1 )
20352 {
20353 error( "argument must be a scalar or vector" ); SWIG_fail;
20354 }
20355 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20356 arg2 = new PLINT[Alen];
20357 temp1 = args(0).matrix_value();
20358 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
20359 }
20360 {
20361 if ( _n_dims( args(1) ) > 1 )
20362 {
20363 error( "argument must be a scalar or vector" ); SWIG_fail;
20364 }
20365 if ( _dim( args(1), 0 ) != Alen )
20366 {
20367 error( "argument vectors must be same length" ); SWIG_fail;
20368 }
20369 temp3 = args(1).matrix_value();
20370 arg3 = new PLINT[Alen];
20371 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
20372 }
20373 plpat(arg1,(int const *)arg2,(int const *)arg3);
20374 _outv = octave_value();
20375 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20376 {
20377 delete [] arg2;
20378 }
20379 {
20380 delete [] arg3;
20381 }
20382 return _out;
20383 fail:
20384 {
20385 delete [] arg2;
20386 }
20387 {
20388 delete [] arg3;
20389 }
20390 return octave_value_list();
20391 }
20392
20393
20394 SWIG_DEFUN( plpath, _wrap_plpath, _wrap_plpath_texinfo ) {
20395 PLINT arg1 ;
20396 PLFLT arg2 ;
20397 PLFLT arg3 ;
20398 PLFLT arg4 ;
20399 PLFLT arg5 ;
20400 int val1 ;
20401 int ecode1 = 0 ;
20402 double val2 ;
20403 int ecode2 = 0 ;
20404 double val3 ;
20405 int ecode3 = 0 ;
20406 double val4 ;
20407 int ecode4 = 0 ;
20408 double val5 ;
20409 int ecode5 = 0 ;
20410 octave_value_list _out;
20411 octave_value_list *_outp=&_out;
20412 octave_value _outv;
20413
20414 if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
20415 SWIG_fail;
20416 }
20417 ecode1 = SWIG_AsVal_int(args(0), &val1);
20418 if (!SWIG_IsOK(ecode1)) {
20419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
20420 }
20421 arg1 = static_cast< PLINT >(val1);
20422 ecode2 = SWIG_AsVal_double(args(1), &val2);
20423 if (!SWIG_IsOK(ecode2)) {
20424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
20425 }
20426 arg2 = static_cast< PLFLT >(val2);
20427 ecode3 = SWIG_AsVal_double(args(2), &val3);
20428 if (!SWIG_IsOK(ecode3)) {
20429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
20430 }
20431 arg3 = static_cast< PLFLT >(val3);
20432 ecode4 = SWIG_AsVal_double(args(3), &val4);
20433 if (!SWIG_IsOK(ecode4)) {
20434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
20435 }
20436 arg4 = static_cast< PLFLT >(val4);
20437 ecode5 = SWIG_AsVal_double(args(4), &val5);
20438 if (!SWIG_IsOK(ecode5)) {
20439 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
20440 }
20441 arg5 = static_cast< PLFLT >(val5);
20442 plpath(arg1,arg2,arg3,arg4,arg5);
20443 _outv = octave_value();
20444 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20445 return _out;
20446 fail:
20447 return octave_value_list();
20448 }
20449
20450
20451 SWIG_DEFUN( plpoin, _wrap_plpoin, _wrap_plpoin_texinfo ) {
20452 PLINT arg1 ;
20453 PLFLT *arg2 = (PLFLT *) 0 ;
20454 PLFLT *arg3 = (PLFLT *) 0 ;
20455 PLINT arg4 ;
20456 Matrix temp1 ;
20457 Matrix temp3 ;
20458 int val4 ;
20459 int ecode4 = 0 ;
20460 octave_value_list _out;
20461 octave_value_list *_outp=&_out;
20462 octave_value _outv;
20463
20464 if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
20465 SWIG_fail;
20466 }
20467 {
20468 if ( _n_dims( args(0) ) > 1 )
20469 {
20470 error( "argument must be a scalar or vector" ); SWIG_fail;
20471 }
20472 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20473 temp1 = args(0).matrix_value();
20474 arg2 = &temp1( 0, 0 );
20475 }
20476 {
20477 if ( _n_dims( args(1) ) > 1 )
20478 {
20479 error( "argument must be a scalar or vector" ); SWIG_fail;
20480 }
20481 if ( _dim( args(1), 0 ) != Alen )
20482 {
20483 error( "argument vectors must be same length" ); SWIG_fail;
20484 }
20485 temp3 = args(1).matrix_value();
20486 arg3 = &temp3( 0, 0 );
20487 }
20488 ecode4 = SWIG_AsVal_int(args(2), &val4);
20489 if (!SWIG_IsOK(ecode4)) {
20490 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
20491 }
20492 arg4 = static_cast< PLINT >(val4);
20493 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
20494 _outv = octave_value();
20495 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20496 {
20497
20498 }
20499 {
20500
20501 }
20502 return _out;
20503 fail:
20504 {
20505
20506 }
20507 {
20508
20509 }
20510 return octave_value_list();
20511 }
20512
20513
20514 SWIG_DEFUN( plpoin3, _wrap_plpoin3, _wrap_plpoin3_texinfo ) {
20515 PLINT arg1 ;
20516 PLFLT *arg2 = (PLFLT *) 0 ;
20517 PLFLT *arg3 = (PLFLT *) 0 ;
20518 PLFLT *arg4 = (PLFLT *) 0 ;
20519 PLINT arg5 ;
20520 Matrix temp1 ;
20521 Matrix temp3 ;
20522 Matrix temp4 ;
20523 int val5 ;
20524 int ecode5 = 0 ;
20525 octave_value_list _out;
20526 octave_value_list *_outp=&_out;
20527 octave_value _outv;
20528
20529 if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
20530 SWIG_fail;
20531 }
20532 {
20533 if ( _n_dims( args(0) ) > 1 )
20534 {
20535 error( "argument must be a scalar or vector" ); SWIG_fail;
20536 }
20537 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20538 temp1 = args(0).matrix_value();
20539 arg2 = &temp1( 0, 0 );
20540 }
20541 {
20542 if ( _n_dims( args(1) ) > 1 )
20543 {
20544 error( "argument must be a scalar or vector" ); SWIG_fail;
20545 }
20546 if ( _dim( args(1), 0 ) != Alen )
20547 {
20548 error( "argument vectors must be same length" ); SWIG_fail;
20549 }
20550 temp3 = args(1).matrix_value();
20551 arg3 = &temp3( 0, 0 );
20552 }
20553 {
20554 if ( _n_dims( args(2) ) > 1 )
20555 {
20556 error( "argument must be a scalar or vector" ); SWIG_fail;
20557 }
20558 if ( _dim( args(2), 0 ) != Alen )
20559 {
20560 error( "argument vectors must be same length" ); SWIG_fail;
20561 }
20562 temp4 = args(2).matrix_value();
20563 arg4 = &temp4( 0, 0 );
20564 }
20565 ecode5 = SWIG_AsVal_int(args(3), &val5);
20566 if (!SWIG_IsOK(ecode5)) {
20567 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
20568 }
20569 arg5 = static_cast< PLINT >(val5);
20570 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
20571 _outv = octave_value();
20572 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20573 {
20574
20575 }
20576 {
20577
20578 }
20579 {
20580
20581 }
20582 return _out;
20583 fail:
20584 {
20585
20586 }
20587 {
20588
20589 }
20590 {
20591
20592 }
20593 return octave_value_list();
20594 }
20595
20596
20597 SWIG_DEFUN( plpoly3, _wrap_plpoly3, _wrap_plpoly3_texinfo ) {
20598 PLINT arg1 ;
20599 PLFLT *arg2 = (PLFLT *) 0 ;
20600 PLFLT *arg3 = (PLFLT *) 0 ;
20601 PLFLT *arg4 = (PLFLT *) 0 ;
20602 PLBOOL *arg5 = (PLBOOL *) 0 ;
20603 PLBOOL arg6 ;
20604 Matrix temp1 ;
20605 Matrix temp3 ;
20606 Matrix temp4 ;
20607 Matrix temp5 ;
20608 int val6 ;
20609 int ecode6 = 0 ;
20610 octave_value_list _out;
20611 octave_value_list *_outp=&_out;
20612 octave_value _outv;
20613
20614 if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
20615 SWIG_fail;
20616 }
20617 {
20618 if ( _n_dims( args(0) ) > 1 )
20619 {
20620 error( "argument must be a scalar or vector" ); SWIG_fail;
20621 }
20622 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
20623 temp1 = args(0).matrix_value();
20624 arg2 = &temp1( 0, 0 );
20625 }
20626 {
20627 if ( _n_dims( args(1) ) > 1 )
20628 {
20629 error( "argument must be a scalar or vector" ); SWIG_fail;
20630 }
20631 if ( _dim( args(1), 0 ) != Alen )
20632 {
20633 error( "argument vectors must be same length" ); SWIG_fail;
20634 }
20635 temp3 = args(1).matrix_value();
20636 arg3 = &temp3( 0, 0 );
20637 }
20638 {
20639 if ( _n_dims( args(2) ) > 1 )
20640 {
20641 error( "argument must be a scalar or vector" ); SWIG_fail;
20642 }
20643 if ( _dim( args(2), 0 ) != Alen )
20644 {
20645 error( "argument vectors must be same length" ); SWIG_fail;
20646 }
20647 temp4 = args(2).matrix_value();
20648 arg4 = &temp4( 0, 0 );
20649 }
20650 {
20651 if ( _n_dims( args(3) ) > 1 )
20652 {
20653 error( "argument must be a scalar or vector" ); SWIG_fail;
20654 }
20655 if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
20656 {
20657 error( "argument vector must be same length or one less" ); SWIG_fail;
20658 }
20659 temp5 = args(3).matrix_value();
20660 arg5 = new PLINT[Alen];
20661 _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
20662 }
20663 ecode6 = SWIG_AsVal_int(args(4), &val6);
20664 if (!SWIG_IsOK(ecode6)) {
20665 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
20666 }
20667 arg6 = static_cast< PLBOOL >(val6);
20668 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
20669 _outv = octave_value();
20670 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20671 {
20672
20673 }
20674 {
20675
20676 }
20677 {
20678
20679 }
20680 {
20681 delete [] arg5;
20682 }
20683 return _out;
20684 fail:
20685 {
20686
20687 }
20688 {
20689
20690 }
20691 {
20692
20693 }
20694 {
20695 delete [] arg5;
20696 }
20697 return octave_value_list();
20698 }
20699
20700
20701 SWIG_DEFUN( plprec, _wrap_plprec, _wrap_plprec_texinfo ) {
20702 PLINT arg1 ;
20703 PLINT arg2 ;
20704 int val1 ;
20705 int ecode1 = 0 ;
20706 int val2 ;
20707 int ecode2 = 0 ;
20708 octave_value_list _out;
20709 octave_value_list *_outp=&_out;
20710 octave_value _outv;
20711
20712 if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
20713 SWIG_fail;
20714 }
20715 ecode1 = SWIG_AsVal_int(args(0), &val1);
20716 if (!SWIG_IsOK(ecode1)) {
20717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
20718 }
20719 arg1 = static_cast< PLINT >(val1);
20720 ecode2 = SWIG_AsVal_int(args(1), &val2);
20721 if (!SWIG_IsOK(ecode2)) {
20722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
20723 }
20724 arg2 = static_cast< PLINT >(val2);
20725 plprec(arg1,arg2);
20726 _outv = octave_value();
20727 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20728 return _out;
20729 fail:
20730 return octave_value_list();
20731 }
20732
20733
20734 SWIG_DEFUN( plpsty, _wrap_plpsty, _wrap_plpsty_texinfo ) {
20735 PLINT arg1 ;
20736 int val1 ;
20737 int ecode1 = 0 ;
20738 octave_value_list _out;
20739 octave_value_list *_outp=&_out;
20740 octave_value _outv;
20741
20742 if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
20743 SWIG_fail;
20744 }
20745 ecode1 = SWIG_AsVal_int(args(0), &val1);
20746 if (!SWIG_IsOK(ecode1)) {
20747 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
20748 }
20749 arg1 = static_cast< PLINT >(val1);
20750 plpsty(arg1);
20751 _outv = octave_value();
20752 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20753 return _out;
20754 fail:
20755 return octave_value_list();
20756 }
20757
20758
20759 SWIG_DEFUN( plptex, _wrap_plptex, _wrap_plptex_texinfo ) {
20760 PLFLT arg1 ;
20761 PLFLT arg2 ;
20762 PLFLT arg3 ;
20763 PLFLT arg4 ;
20764 PLFLT arg5 ;
20765 char *arg6 = (char *) 0 ;
20766 double val1 ;
20767 int ecode1 = 0 ;
20768 double val2 ;
20769 int ecode2 = 0 ;
20770 double val3 ;
20771 int ecode3 = 0 ;
20772 double val4 ;
20773 int ecode4 = 0 ;
20774 double val5 ;
20775 int ecode5 = 0 ;
20776 int res6 ;
20777 char *buf6 = 0 ;
20778 int alloc6 = 0 ;
20779 octave_value_list _out;
20780 octave_value_list *_outp=&_out;
20781 octave_value _outv;
20782
20783 if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
20784 SWIG_fail;
20785 }
20786 ecode1 = SWIG_AsVal_double(args(0), &val1);
20787 if (!SWIG_IsOK(ecode1)) {
20788 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
20789 }
20790 arg1 = static_cast< PLFLT >(val1);
20791 ecode2 = SWIG_AsVal_double(args(1), &val2);
20792 if (!SWIG_IsOK(ecode2)) {
20793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
20794 }
20795 arg2 = static_cast< PLFLT >(val2);
20796 ecode3 = SWIG_AsVal_double(args(2), &val3);
20797 if (!SWIG_IsOK(ecode3)) {
20798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
20799 }
20800 arg3 = static_cast< PLFLT >(val3);
20801 ecode4 = SWIG_AsVal_double(args(3), &val4);
20802 if (!SWIG_IsOK(ecode4)) {
20803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
20804 }
20805 arg4 = static_cast< PLFLT >(val4);
20806 ecode5 = SWIG_AsVal_double(args(4), &val5);
20807 if (!SWIG_IsOK(ecode5)) {
20808 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
20809 }
20810 arg5 = static_cast< PLFLT >(val5);
20811 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
20812 if (!SWIG_IsOK(res6)) {
20813 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
20814 }
20815 arg6 = reinterpret_cast< char * >(buf6);
20816 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
20817 _outv = octave_value();
20818 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20819 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
20820 return _out;
20821 fail:
20822 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
20823 return octave_value_list();
20824 }
20825
20826
20827 SWIG_DEFUN( plptex3, _wrap_plptex3, _wrap_plptex3_texinfo ) {
20828 PLFLT arg1 ;
20829 PLFLT arg2 ;
20830 PLFLT arg3 ;
20831 PLFLT arg4 ;
20832 PLFLT arg5 ;
20833 PLFLT arg6 ;
20834 PLFLT arg7 ;
20835 PLFLT arg8 ;
20836 PLFLT arg9 ;
20837 PLFLT arg10 ;
20838 char *arg11 = (char *) 0 ;
20839 double val1 ;
20840 int ecode1 = 0 ;
20841 double val2 ;
20842 int ecode2 = 0 ;
20843 double val3 ;
20844 int ecode3 = 0 ;
20845 double val4 ;
20846 int ecode4 = 0 ;
20847 double val5 ;
20848 int ecode5 = 0 ;
20849 double val6 ;
20850 int ecode6 = 0 ;
20851 double val7 ;
20852 int ecode7 = 0 ;
20853 double val8 ;
20854 int ecode8 = 0 ;
20855 double val9 ;
20856 int ecode9 = 0 ;
20857 double val10 ;
20858 int ecode10 = 0 ;
20859 int res11 ;
20860 char *buf11 = 0 ;
20861 int alloc11 = 0 ;
20862 octave_value_list _out;
20863 octave_value_list *_outp=&_out;
20864 octave_value _outv;
20865
20866 if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
20867 SWIG_fail;
20868 }
20869 ecode1 = SWIG_AsVal_double(args(0), &val1);
20870 if (!SWIG_IsOK(ecode1)) {
20871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
20872 }
20873 arg1 = static_cast< PLFLT >(val1);
20874 ecode2 = SWIG_AsVal_double(args(1), &val2);
20875 if (!SWIG_IsOK(ecode2)) {
20876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
20877 }
20878 arg2 = static_cast< PLFLT >(val2);
20879 ecode3 = SWIG_AsVal_double(args(2), &val3);
20880 if (!SWIG_IsOK(ecode3)) {
20881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
20882 }
20883 arg3 = static_cast< PLFLT >(val3);
20884 ecode4 = SWIG_AsVal_double(args(3), &val4);
20885 if (!SWIG_IsOK(ecode4)) {
20886 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
20887 }
20888 arg4 = static_cast< PLFLT >(val4);
20889 ecode5 = SWIG_AsVal_double(args(4), &val5);
20890 if (!SWIG_IsOK(ecode5)) {
20891 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
20892 }
20893 arg5 = static_cast< PLFLT >(val5);
20894 ecode6 = SWIG_AsVal_double(args(5), &val6);
20895 if (!SWIG_IsOK(ecode6)) {
20896 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
20897 }
20898 arg6 = static_cast< PLFLT >(val6);
20899 ecode7 = SWIG_AsVal_double(args(6), &val7);
20900 if (!SWIG_IsOK(ecode7)) {
20901 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
20902 }
20903 arg7 = static_cast< PLFLT >(val7);
20904 ecode8 = SWIG_AsVal_double(args(7), &val8);
20905 if (!SWIG_IsOK(ecode8)) {
20906 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
20907 }
20908 arg8 = static_cast< PLFLT >(val8);
20909 ecode9 = SWIG_AsVal_double(args(8), &val9);
20910 if (!SWIG_IsOK(ecode9)) {
20911 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
20912 }
20913 arg9 = static_cast< PLFLT >(val9);
20914 ecode10 = SWIG_AsVal_double(args(9), &val10);
20915 if (!SWIG_IsOK(ecode10)) {
20916 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
20917 }
20918 arg10 = static_cast< PLFLT >(val10);
20919 res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
20920 if (!SWIG_IsOK(res11)) {
20921 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
20922 }
20923 arg11 = reinterpret_cast< char * >(buf11);
20924 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
20925 _outv = octave_value();
20926 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20927 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
20928 return _out;
20929 fail:
20930 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
20931 return octave_value_list();
20932 }
20933
20934
20935 SWIG_DEFUN( plrandd, _wrap_plrandd, _wrap_plrandd_texinfo ) {
20936 octave_value_list _out;
20937 octave_value_list *_outp=&_out;
20938 octave_value _outv;
20939 PLFLT result;
20940
20941 if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
20942 SWIG_fail;
20943 }
20944 result = (PLFLT)plrandd();
20945 _outv = SWIG_From_double(static_cast< double >(result));
20946 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20947 return _out;
20948 fail:
20949 return octave_value_list();
20950 }
20951
20952
20953 SWIG_DEFUN( plreplot, _wrap_plreplot, _wrap_plreplot_texinfo ) {
20954 octave_value_list _out;
20955 octave_value_list *_outp=&_out;
20956 octave_value _outv;
20957
20958 if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
20959 SWIG_fail;
20960 }
20961 plreplot();
20962 _outv = octave_value();
20963 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20964 return _out;
20965 fail:
20966 return octave_value_list();
20967 }
20968
20969
20970 SWIG_DEFUN( plrgbhls, _wrap_plrgbhls, _wrap_plrgbhls_texinfo ) {
20971 PLFLT arg1 ;
20972 PLFLT arg2 ;
20973 PLFLT arg3 ;
20974 PLFLT *arg4 = (PLFLT *) 0 ;
20975 PLFLT *arg5 = (PLFLT *) 0 ;
20976 PLFLT *arg6 = (PLFLT *) 0 ;
20977 double val1 ;
20978 int ecode1 = 0 ;
20979 double val2 ;
20980 int ecode2 = 0 ;
20981 double val3 ;
20982 int ecode3 = 0 ;
20983 PLFLT temp4 ;
20984 int res4 = SWIG_TMPOBJ ;
20985 PLFLT temp5 ;
20986 int res5 = SWIG_TMPOBJ ;
20987 PLFLT temp6 ;
20988 int res6 = SWIG_TMPOBJ ;
20989 octave_value_list _out;
20990 octave_value_list *_outp=&_out;
20991 octave_value _outv;
20992
20993 arg4 = &temp4;
20994 arg5 = &temp5;
20995 arg6 = &temp6;
20996 if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
20997 SWIG_fail;
20998 }
20999 ecode1 = SWIG_AsVal_double(args(0), &val1);
21000 if (!SWIG_IsOK(ecode1)) {
21001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
21002 }
21003 arg1 = static_cast< PLFLT >(val1);
21004 ecode2 = SWIG_AsVal_double(args(1), &val2);
21005 if (!SWIG_IsOK(ecode2)) {
21006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
21007 }
21008 arg2 = static_cast< PLFLT >(val2);
21009 ecode3 = SWIG_AsVal_double(args(2), &val3);
21010 if (!SWIG_IsOK(ecode3)) {
21011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
21012 }
21013 arg3 = static_cast< PLFLT >(val3);
21014 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
21015 _outv = octave_value();
21016 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21017 if (SWIG_IsTmpObj(res4)) {
21018 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
21019 } else {
21020 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21021 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
21022 }
21023 if (SWIG_IsTmpObj(res5)) {
21024 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
21025 } else {
21026 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21027 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
21028 }
21029 if (SWIG_IsTmpObj(res6)) {
21030 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
21031 } else {
21032 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21033 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
21034 }
21035 return _out;
21036 fail:
21037 return octave_value_list();
21038 }
21039
21040
21041 SWIG_DEFUN( plschr, _wrap_plschr, _wrap_plschr_texinfo ) {
21042 PLFLT arg1 ;
21043 PLFLT arg2 ;
21044 double val1 ;
21045 int ecode1 = 0 ;
21046 double val2 ;
21047 int ecode2 = 0 ;
21048 octave_value_list _out;
21049 octave_value_list *_outp=&_out;
21050 octave_value _outv;
21051
21052 if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
21053 SWIG_fail;
21054 }
21055 ecode1 = SWIG_AsVal_double(args(0), &val1);
21056 if (!SWIG_IsOK(ecode1)) {
21057 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
21058 }
21059 arg1 = static_cast< PLFLT >(val1);
21060 ecode2 = SWIG_AsVal_double(args(1), &val2);
21061 if (!SWIG_IsOK(ecode2)) {
21062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
21063 }
21064 arg2 = static_cast< PLFLT >(val2);
21065 plschr(arg1,arg2);
21066 _outv = octave_value();
21067 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21068 return _out;
21069 fail:
21070 return octave_value_list();
21071 }
21072
21073
21074 SWIG_DEFUN( plscmap0, _wrap_plscmap0, _wrap_plscmap0_texinfo ) {
21075 PLINT *arg1 = (PLINT *) 0 ;
21076 PLINT *arg2 = (PLINT *) 0 ;
21077 PLINT *arg3 = (PLINT *) 0 ;
21078 PLINT arg4 ;
21079 Matrix temp1 ;
21080 Matrix temp2 ;
21081 Matrix temp3 ;
21082 octave_value_list _out;
21083 octave_value_list *_outp=&_out;
21084 octave_value _outv;
21085
21086 if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
21087 SWIG_fail;
21088 }
21089 {
21090 if ( _n_dims( args(0) ) > 1 )
21091 {
21092 error( "argument must be a scalar or vector" ); SWIG_fail;
21093 }
21094 Alen = (PLINT) ( _dim( args(0), 0 ) );
21095 temp1 = args(0).matrix_value();
21096 arg1 = new PLINT[Alen];
21097 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21098 }
21099 {
21100 if ( _n_dims( args(1) ) > 1 )
21101 {
21102 error( "argument must be a scalar or vector" ); SWIG_fail;
21103 }
21104 if ( _dim( args(1), 0 ) != Alen )
21105 {
21106 error( "argument vectors must be same length" ); SWIG_fail;
21107 }
21108 temp2 = args(1).matrix_value();
21109 arg2 = new PLINT[Alen];
21110 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21111 }
21112 {
21113 if ( _n_dims( args(2) ) > 1 )
21114 {
21115 error( "argument must be a scalar or vector" ); SWIG_fail;
21116 }
21117 if ( _dim( args(2), 0 ) != Alen )
21118 {
21119 error( "argument vectors must be same length" ); SWIG_fail;
21120 }
21121 temp3 = args(2).matrix_value();
21122 arg3 = new PLINT[Alen];
21123 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21124 arg4 = Alen;
21125 }
21126 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
21127 _outv = octave_value();
21128 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21129 {
21130 delete [] arg1;
21131 }
21132 {
21133 delete [] arg2;
21134 }
21135 {
21136 delete [] arg3;
21137 }
21138 return _out;
21139 fail:
21140 {
21141 delete [] arg1;
21142 }
21143 {
21144 delete [] arg2;
21145 }
21146 {
21147 delete [] arg3;
21148 }
21149 return octave_value_list();
21150 }
21151
21152
21153 SWIG_DEFUN( plscmap0a, _wrap_plscmap0a, _wrap_plscmap0a_texinfo ) {
21154 PLINT *arg1 = (PLINT *) 0 ;
21155 PLINT *arg2 = (PLINT *) 0 ;
21156 PLINT *arg3 = (PLINT *) 0 ;
21157 PLFLT *arg4 = (PLFLT *) 0 ;
21158 PLINT arg5 ;
21159 Matrix temp1 ;
21160 Matrix temp2 ;
21161 Matrix temp3 ;
21162 Matrix temp4 ;
21163 octave_value_list _out;
21164 octave_value_list *_outp=&_out;
21165 octave_value _outv;
21166
21167 if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
21168 SWIG_fail;
21169 }
21170 {
21171 if ( _n_dims( args(0) ) > 1 )
21172 {
21173 error( "argument must be a scalar or vector" ); SWIG_fail;
21174 }
21175 Alen = (PLINT) ( _dim( args(0), 0 ) );
21176 temp1 = args(0).matrix_value();
21177 arg1 = new PLINT[Alen];
21178 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21179 }
21180 {
21181 if ( _n_dims( args(1) ) > 1 )
21182 {
21183 error( "argument must be a scalar or vector" ); SWIG_fail;
21184 }
21185 if ( _dim( args(1), 0 ) != Alen )
21186 {
21187 error( "argument vectors must be same length" ); SWIG_fail;
21188 }
21189 temp2 = args(1).matrix_value();
21190 arg2 = new PLINT[Alen];
21191 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21192 }
21193 {
21194 if ( _n_dims( args(2) ) > 1 )
21195 {
21196 error( "argument must be a scalar or vector" ); SWIG_fail;
21197 }
21198 if ( _dim( args(2), 0 ) != Alen )
21199 {
21200 error( "argument vectors must be same length" ); SWIG_fail;
21201 }
21202 temp3 = args(2).matrix_value();
21203 arg3 = new PLINT[Alen];
21204 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21205 }
21206 {
21207 if ( _n_dims( args(3) ) > 1 )
21208 {
21209 error( "argument must be a scalar or vector" ); SWIG_fail;
21210 }
21211 if ( _dim( args(3), 0 ) != Alen )
21212 {
21213 error( "argument vectors must be same length" ); SWIG_fail;
21214 }
21215 temp4 = args(3).matrix_value();
21216 arg4 = &temp4( 0, 0 );
21217 arg5 = (PLINT) ( _dim( args(3), 0 ) );
21218 }
21219 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
21220 _outv = octave_value();
21221 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21222 {
21223 delete [] arg1;
21224 }
21225 {
21226 delete [] arg2;
21227 }
21228 {
21229 delete [] arg3;
21230 }
21231 {
21232
21233 }
21234 return _out;
21235 fail:
21236 {
21237 delete [] arg1;
21238 }
21239 {
21240 delete [] arg2;
21241 }
21242 {
21243 delete [] arg3;
21244 }
21245 {
21246
21247 }
21248 return octave_value_list();
21249 }
21250
21251
21252 SWIG_DEFUN( plscmap0n, _wrap_plscmap0n, _wrap_plscmap0n_texinfo ) {
21253 PLINT arg1 ;
21254 int val1 ;
21255 int ecode1 = 0 ;
21256 octave_value_list _out;
21257 octave_value_list *_outp=&_out;
21258 octave_value _outv;
21259
21260 if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
21261 SWIG_fail;
21262 }
21263 ecode1 = SWIG_AsVal_int(args(0), &val1);
21264 if (!SWIG_IsOK(ecode1)) {
21265 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
21266 }
21267 arg1 = static_cast< PLINT >(val1);
21268 plscmap0n(arg1);
21269 _outv = octave_value();
21270 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21271 return _out;
21272 fail:
21273 return octave_value_list();
21274 }
21275
21276
21277 SWIG_DEFUN( plscmap1, _wrap_plscmap1, _wrap_plscmap1_texinfo ) {
21278 PLINT *arg1 = (PLINT *) 0 ;
21279 PLINT *arg2 = (PLINT *) 0 ;
21280 PLINT *arg3 = (PLINT *) 0 ;
21281 PLINT arg4 ;
21282 Matrix temp1 ;
21283 Matrix temp2 ;
21284 Matrix temp3 ;
21285 octave_value_list _out;
21286 octave_value_list *_outp=&_out;
21287 octave_value _outv;
21288
21289 if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
21290 SWIG_fail;
21291 }
21292 {
21293 if ( _n_dims( args(0) ) > 1 )
21294 {
21295 error( "argument must be a scalar or vector" ); SWIG_fail;
21296 }
21297 Alen = (PLINT) ( _dim( args(0), 0 ) );
21298 temp1 = args(0).matrix_value();
21299 arg1 = new PLINT[Alen];
21300 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21301 }
21302 {
21303 if ( _n_dims( args(1) ) > 1 )
21304 {
21305 error( "argument must be a scalar or vector" ); SWIG_fail;
21306 }
21307 if ( _dim( args(1), 0 ) != Alen )
21308 {
21309 error( "argument vectors must be same length" ); SWIG_fail;
21310 }
21311 temp2 = args(1).matrix_value();
21312 arg2 = new PLINT[Alen];
21313 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21314 }
21315 {
21316 if ( _n_dims( args(2) ) > 1 )
21317 {
21318 error( "argument must be a scalar or vector" ); SWIG_fail;
21319 }
21320 if ( _dim( args(2), 0 ) != Alen )
21321 {
21322 error( "argument vectors must be same length" ); SWIG_fail;
21323 }
21324 temp3 = args(2).matrix_value();
21325 arg3 = new PLINT[Alen];
21326 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21327 arg4 = Alen;
21328 }
21329 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
21330 _outv = octave_value();
21331 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21332 {
21333 delete [] arg1;
21334 }
21335 {
21336 delete [] arg2;
21337 }
21338 {
21339 delete [] arg3;
21340 }
21341 return _out;
21342 fail:
21343 {
21344 delete [] arg1;
21345 }
21346 {
21347 delete [] arg2;
21348 }
21349 {
21350 delete [] arg3;
21351 }
21352 return octave_value_list();
21353 }
21354
21355
21356 SWIG_DEFUN( plscmap1a, _wrap_plscmap1a, _wrap_plscmap1a_texinfo ) {
21357 PLINT *arg1 = (PLINT *) 0 ;
21358 PLINT *arg2 = (PLINT *) 0 ;
21359 PLINT *arg3 = (PLINT *) 0 ;
21360 PLFLT *arg4 = (PLFLT *) 0 ;
21361 PLINT arg5 ;
21362 Matrix temp1 ;
21363 Matrix temp2 ;
21364 Matrix temp3 ;
21365 Matrix temp4 ;
21366 octave_value_list _out;
21367 octave_value_list *_outp=&_out;
21368 octave_value _outv;
21369
21370 if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
21371 SWIG_fail;
21372 }
21373 {
21374 if ( _n_dims( args(0) ) > 1 )
21375 {
21376 error( "argument must be a scalar or vector" ); SWIG_fail;
21377 }
21378 Alen = (PLINT) ( _dim( args(0), 0 ) );
21379 temp1 = args(0).matrix_value();
21380 arg1 = new PLINT[Alen];
21381 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
21382 }
21383 {
21384 if ( _n_dims( args(1) ) > 1 )
21385 {
21386 error( "argument must be a scalar or vector" ); SWIG_fail;
21387 }
21388 if ( _dim( args(1), 0 ) != Alen )
21389 {
21390 error( "argument vectors must be same length" ); SWIG_fail;
21391 }
21392 temp2 = args(1).matrix_value();
21393 arg2 = new PLINT[Alen];
21394 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
21395 }
21396 {
21397 if ( _n_dims( args(2) ) > 1 )
21398 {
21399 error( "argument must be a scalar or vector" ); SWIG_fail;
21400 }
21401 if ( _dim( args(2), 0 ) != Alen )
21402 {
21403 error( "argument vectors must be same length" ); SWIG_fail;
21404 }
21405 temp3 = args(2).matrix_value();
21406 arg3 = new PLINT[Alen];
21407 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
21408 }
21409 {
21410 if ( _n_dims( args(3) ) > 1 )
21411 {
21412 error( "argument must be a scalar or vector" ); SWIG_fail;
21413 }
21414 if ( _dim( args(3), 0 ) != Alen )
21415 {
21416 error( "argument vectors must be same length" ); SWIG_fail;
21417 }
21418 temp4 = args(3).matrix_value();
21419 arg4 = &temp4( 0, 0 );
21420 arg5 = (PLINT) ( _dim( args(3), 0 ) );
21421 }
21422 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
21423 _outv = octave_value();
21424 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21425 {
21426 delete [] arg1;
21427 }
21428 {
21429 delete [] arg2;
21430 }
21431 {
21432 delete [] arg3;
21433 }
21434 {
21435
21436 }
21437 return _out;
21438 fail:
21439 {
21440 delete [] arg1;
21441 }
21442 {
21443 delete [] arg2;
21444 }
21445 {
21446 delete [] arg3;
21447 }
21448 {
21449
21450 }
21451 return octave_value_list();
21452 }
21453
21454
21455 SWIG_DEFUN( plscmap1l, _wrap_plscmap1l, _wrap_plscmap1l_texinfo ) {
21456 PLBOOL arg1 ;
21457 PLINT arg2 ;
21458 PLFLT *arg3 = (PLFLT *) 0 ;
21459 PLFLT *arg4 = (PLFLT *) 0 ;
21460 PLFLT *arg5 = (PLFLT *) 0 ;
21461 PLFLT *arg6 = (PLFLT *) 0 ;
21462 PLBOOL *arg7 = (PLBOOL *) 0 ;
21463 int val1 ;
21464 int ecode1 = 0 ;
21465 Matrix temp2 ;
21466 Matrix temp4 ;
21467 Matrix temp5 ;
21468 Matrix temp6 ;
21469 Matrix temp7 ;
21470 octave_value_list _out;
21471 octave_value_list *_outp=&_out;
21472 octave_value _outv;
21473
21474 if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
21475 SWIG_fail;
21476 }
21477 ecode1 = SWIG_AsVal_int(args(0), &val1);
21478 if (!SWIG_IsOK(ecode1)) {
21479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
21480 }
21481 arg1 = static_cast< PLBOOL >(val1);
21482 {
21483 if ( _n_dims( args(1) ) > 1 )
21484 {
21485 error( "argument must be a scalar or vector" ); SWIG_fail;
21486 }
21487 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
21488 temp2 = args(1).matrix_value();
21489 arg3 = &temp2( 0, 0 );
21490 }
21491 {
21492 if ( _n_dims( args(2) ) > 1 )
21493 {
21494 error( "argument must be a scalar or vector" ); SWIG_fail;
21495 }
21496 if ( _dim( args(2), 0 ) != Alen )
21497 {
21498 error( "argument vectors must be same length" ); SWIG_fail;
21499 }
21500 temp4 = args(2).matrix_value();
21501 arg4 = &temp4( 0, 0 );
21502 }
21503 {
21504 if ( _n_dims( args(3) ) > 1 )
21505 {
21506 error( "argument must be a scalar or vector" ); SWIG_fail;
21507 }
21508 if ( _dim( args(3), 0 ) != Alen )
21509 {
21510 error( "argument vectors must be same length" ); SWIG_fail;
21511 }
21512 temp5 = args(3).matrix_value();
21513 arg5 = &temp5( 0, 0 );
21514 }
21515 {
21516 if ( _n_dims( args(4) ) > 1 )
21517 {
21518 error( "argument must be a scalar or vector" ); SWIG_fail;
21519 }
21520 if ( _dim( args(4), 0 ) != Alen )
21521 {
21522 error( "argument vectors must be same length" ); SWIG_fail;
21523 }
21524 temp6 = args(4).matrix_value();
21525 arg6 = &temp6( 0, 0 );
21526 }
21527 {
21528 if ( _n_dims( args(5) ) > 1 )
21529 {
21530 error( "argument must be a scalar or vector" ); SWIG_fail;
21531 }
21532 if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
21533 {
21534 error( "argument vector must be same length or one less" ); SWIG_fail;
21535 }
21536 temp7 = args(5).matrix_value();
21537 arg7 = new PLINT[Alen];
21538 _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
21539 }
21540 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
21541 _outv = octave_value();
21542 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21543 {
21544
21545 }
21546 {
21547
21548 }
21549 {
21550
21551 }
21552 {
21553
21554 }
21555 {
21556 delete [] arg7;
21557 }
21558 return _out;
21559 fail:
21560 {
21561
21562 }
21563 {
21564
21565 }
21566 {
21567
21568 }
21569 {
21570
21571 }
21572 {
21573 delete [] arg7;
21574 }
21575 return octave_value_list();
21576 }
21577
21578
21579 SWIG_DEFUN( plscmap1la, _wrap_plscmap1la, _wrap_plscmap1la_texinfo ) {
21580 PLBOOL arg1 ;
21581 PLINT arg2 ;
21582 PLFLT *arg3 = (PLFLT *) 0 ;
21583 PLFLT *arg4 = (PLFLT *) 0 ;
21584 PLFLT *arg5 = (PLFLT *) 0 ;
21585 PLFLT *arg6 = (PLFLT *) 0 ;
21586 PLFLT *arg7 = (PLFLT *) 0 ;
21587 PLBOOL *arg8 = (PLBOOL *) 0 ;
21588 int val1 ;
21589 int ecode1 = 0 ;
21590 Matrix temp2 ;
21591 Matrix temp4 ;
21592 Matrix temp5 ;
21593 Matrix temp6 ;
21594 Matrix temp7 ;
21595 Matrix temp8 ;
21596 octave_value_list _out;
21597 octave_value_list *_outp=&_out;
21598 octave_value _outv;
21599
21600 if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
21601 SWIG_fail;
21602 }
21603 ecode1 = SWIG_AsVal_int(args(0), &val1);
21604 if (!SWIG_IsOK(ecode1)) {
21605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
21606 }
21607 arg1 = static_cast< PLBOOL >(val1);
21608 {
21609 if ( _n_dims( args(1) ) > 1 )
21610 {
21611 error( "argument must be a scalar or vector" ); SWIG_fail;
21612 }
21613 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
21614 temp2 = args(1).matrix_value();
21615 arg3 = &temp2( 0, 0 );
21616 }
21617 {
21618 if ( _n_dims( args(2) ) > 1 )
21619 {
21620 error( "argument must be a scalar or vector" ); SWIG_fail;
21621 }
21622 if ( _dim( args(2), 0 ) != Alen )
21623 {
21624 error( "argument vectors must be same length" ); SWIG_fail;
21625 }
21626 temp4 = args(2).matrix_value();
21627 arg4 = &temp4( 0, 0 );
21628 }
21629 {
21630 if ( _n_dims( args(3) ) > 1 )
21631 {
21632 error( "argument must be a scalar or vector" ); SWIG_fail;
21633 }
21634 if ( _dim( args(3), 0 ) != Alen )
21635 {
21636 error( "argument vectors must be same length" ); SWIG_fail;
21637 }
21638 temp5 = args(3).matrix_value();
21639 arg5 = &temp5( 0, 0 );
21640 }
21641 {
21642 if ( _n_dims( args(4) ) > 1 )
21643 {
21644 error( "argument must be a scalar or vector" ); SWIG_fail;
21645 }
21646 if ( _dim( args(4), 0 ) != Alen )
21647 {
21648 error( "argument vectors must be same length" ); SWIG_fail;
21649 }
21650 temp6 = args(4).matrix_value();
21651 arg6 = &temp6( 0, 0 );
21652 }
21653 {
21654 if ( _n_dims( args(5) ) > 1 )
21655 {
21656 error( "argument must be a scalar or vector" ); SWIG_fail;
21657 }
21658 if ( _dim( args(5), 0 ) != Alen )
21659 {
21660 error( "argument vectors must be same length" ); SWIG_fail;
21661 }
21662 temp7 = args(5).matrix_value();
21663 arg7 = &temp7( 0, 0 );
21664 }
21665 {
21666 if ( _n_dims( args(6) ) > 1 )
21667 {
21668 error( "argument must be a scalar or vector" ); SWIG_fail;
21669 }
21670 if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
21671 {
21672 error( "argument vector must be same length or one less" ); SWIG_fail;
21673 }
21674 temp8 = args(6).matrix_value();
21675 arg8 = new PLINT[Alen];
21676 _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
21677 }
21678 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
21679 _outv = octave_value();
21680 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21681 {
21682
21683 }
21684 {
21685
21686 }
21687 {
21688
21689 }
21690 {
21691
21692 }
21693 {
21694
21695 }
21696 {
21697 delete [] arg8;
21698 }
21699 return _out;
21700 fail:
21701 {
21702
21703 }
21704 {
21705
21706 }
21707 {
21708
21709 }
21710 {
21711
21712 }
21713 {
21714
21715 }
21716 {
21717 delete [] arg8;
21718 }
21719 return octave_value_list();
21720 }
21721
21722
21723 SWIG_DEFUN( plscmap1n, _wrap_plscmap1n, _wrap_plscmap1n_texinfo ) {
21724 PLINT arg1 ;
21725 int val1 ;
21726 int ecode1 = 0 ;
21727 octave_value_list _out;
21728 octave_value_list *_outp=&_out;
21729 octave_value _outv;
21730
21731 if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
21732 SWIG_fail;
21733 }
21734 ecode1 = SWIG_AsVal_int(args(0), &val1);
21735 if (!SWIG_IsOK(ecode1)) {
21736 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
21737 }
21738 arg1 = static_cast< PLINT >(val1);
21739 plscmap1n(arg1);
21740 _outv = octave_value();
21741 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21742 return _out;
21743 fail:
21744 return octave_value_list();
21745 }
21746
21747
21748 SWIG_DEFUN( plscmap1_range, _wrap_plscmap1_range, _wrap_plscmap1_range_texinfo ) {
21749 PLFLT arg1 ;
21750 PLFLT arg2 ;
21751 double val1 ;
21752 int ecode1 = 0 ;
21753 double val2 ;
21754 int ecode2 = 0 ;
21755 octave_value_list _out;
21756 octave_value_list *_outp=&_out;
21757 octave_value _outv;
21758
21759 if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
21760 SWIG_fail;
21761 }
21762 ecode1 = SWIG_AsVal_double(args(0), &val1);
21763 if (!SWIG_IsOK(ecode1)) {
21764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
21765 }
21766 arg1 = static_cast< PLFLT >(val1);
21767 ecode2 = SWIG_AsVal_double(args(1), &val2);
21768 if (!SWIG_IsOK(ecode2)) {
21769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
21770 }
21771 arg2 = static_cast< PLFLT >(val2);
21772 plscmap1_range(arg1,arg2);
21773 _outv = octave_value();
21774 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21775 return _out;
21776 fail:
21777 return octave_value_list();
21778 }
21779
21780
21781 SWIG_DEFUN( plgcmap1_range, _wrap_plgcmap1_range, _wrap_plgcmap1_range_texinfo ) {
21782 PLFLT *arg1 = (PLFLT *) 0 ;
21783 PLFLT *arg2 = (PLFLT *) 0 ;
21784 PLFLT temp1 ;
21785 int res1 = SWIG_TMPOBJ ;
21786 PLFLT temp2 ;
21787 int res2 = SWIG_TMPOBJ ;
21788 octave_value_list _out;
21789 octave_value_list *_outp=&_out;
21790 octave_value _outv;
21791
21792 arg1 = &temp1;
21793 arg2 = &temp2;
21794 if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
21795 SWIG_fail;
21796 }
21797 plgcmap1_range(arg1,arg2);
21798 _outv = octave_value();
21799 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21800 if (SWIG_IsTmpObj(res1)) {
21801 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
21802 } else {
21803 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21804 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
21805 }
21806 if (SWIG_IsTmpObj(res2)) {
21807 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
21808 } else {
21809 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21810 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
21811 }
21812 return _out;
21813 fail:
21814 return octave_value_list();
21815 }
21816
21817
21818 SWIG_DEFUN( plscol0, _wrap_plscol0, _wrap_plscol0_texinfo ) {
21819 PLINT arg1 ;
21820 PLINT arg2 ;
21821 PLINT arg3 ;
21822 PLINT arg4 ;
21823 int val1 ;
21824 int ecode1 = 0 ;
21825 int val2 ;
21826 int ecode2 = 0 ;
21827 int val3 ;
21828 int ecode3 = 0 ;
21829 int val4 ;
21830 int ecode4 = 0 ;
21831 octave_value_list _out;
21832 octave_value_list *_outp=&_out;
21833 octave_value _outv;
21834
21835 if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
21836 SWIG_fail;
21837 }
21838 ecode1 = SWIG_AsVal_int(args(0), &val1);
21839 if (!SWIG_IsOK(ecode1)) {
21840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
21841 }
21842 arg1 = static_cast< PLINT >(val1);
21843 ecode2 = SWIG_AsVal_int(args(1), &val2);
21844 if (!SWIG_IsOK(ecode2)) {
21845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
21846 }
21847 arg2 = static_cast< PLINT >(val2);
21848 ecode3 = SWIG_AsVal_int(args(2), &val3);
21849 if (!SWIG_IsOK(ecode3)) {
21850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
21851 }
21852 arg3 = static_cast< PLINT >(val3);
21853 ecode4 = SWIG_AsVal_int(args(3), &val4);
21854 if (!SWIG_IsOK(ecode4)) {
21855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
21856 }
21857 arg4 = static_cast< PLINT >(val4);
21858 plscol0(arg1,arg2,arg3,arg4);
21859 _outv = octave_value();
21860 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21861 return _out;
21862 fail:
21863 return octave_value_list();
21864 }
21865
21866
21867 SWIG_DEFUN( plscol0a, _wrap_plscol0a, _wrap_plscol0a_texinfo ) {
21868 PLINT arg1 ;
21869 PLINT arg2 ;
21870 PLINT arg3 ;
21871 PLINT arg4 ;
21872 PLFLT arg5 ;
21873 int val1 ;
21874 int ecode1 = 0 ;
21875 int val2 ;
21876 int ecode2 = 0 ;
21877 int val3 ;
21878 int ecode3 = 0 ;
21879 int val4 ;
21880 int ecode4 = 0 ;
21881 double val5 ;
21882 int ecode5 = 0 ;
21883 octave_value_list _out;
21884 octave_value_list *_outp=&_out;
21885 octave_value _outv;
21886
21887 if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
21888 SWIG_fail;
21889 }
21890 ecode1 = SWIG_AsVal_int(args(0), &val1);
21891 if (!SWIG_IsOK(ecode1)) {
21892 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
21893 }
21894 arg1 = static_cast< PLINT >(val1);
21895 ecode2 = SWIG_AsVal_int(args(1), &val2);
21896 if (!SWIG_IsOK(ecode2)) {
21897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
21898 }
21899 arg2 = static_cast< PLINT >(val2);
21900 ecode3 = SWIG_AsVal_int(args(2), &val3);
21901 if (!SWIG_IsOK(ecode3)) {
21902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
21903 }
21904 arg3 = static_cast< PLINT >(val3);
21905 ecode4 = SWIG_AsVal_int(args(3), &val4);
21906 if (!SWIG_IsOK(ecode4)) {
21907 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
21908 }
21909 arg4 = static_cast< PLINT >(val4);
21910 ecode5 = SWIG_AsVal_double(args(4), &val5);
21911 if (!SWIG_IsOK(ecode5)) {
21912 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
21913 }
21914 arg5 = static_cast< PLFLT >(val5);
21915 plscol0a(arg1,arg2,arg3,arg4,arg5);
21916 _outv = octave_value();
21917 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21918 return _out;
21919 fail:
21920 return octave_value_list();
21921 }
21922
21923
21924 SWIG_DEFUN( plscolbg, _wrap_plscolbg, _wrap_plscolbg_texinfo ) {
21925 PLINT arg1 ;
21926 PLINT arg2 ;
21927 PLINT arg3 ;
21928 int val1 ;
21929 int ecode1 = 0 ;
21930 int val2 ;
21931 int ecode2 = 0 ;
21932 int val3 ;
21933 int ecode3 = 0 ;
21934 octave_value_list _out;
21935 octave_value_list *_outp=&_out;
21936 octave_value _outv;
21937
21938 if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
21939 SWIG_fail;
21940 }
21941 ecode1 = SWIG_AsVal_int(args(0), &val1);
21942 if (!SWIG_IsOK(ecode1)) {
21943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
21944 }
21945 arg1 = static_cast< PLINT >(val1);
21946 ecode2 = SWIG_AsVal_int(args(1), &val2);
21947 if (!SWIG_IsOK(ecode2)) {
21948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
21949 }
21950 arg2 = static_cast< PLINT >(val2);
21951 ecode3 = SWIG_AsVal_int(args(2), &val3);
21952 if (!SWIG_IsOK(ecode3)) {
21953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
21954 }
21955 arg3 = static_cast< PLINT >(val3);
21956 plscolbg(arg1,arg2,arg3);
21957 _outv = octave_value();
21958 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
21959 return _out;
21960 fail:
21961 return octave_value_list();
21962 }
21963
21964
21965 SWIG_DEFUN( plscolbga, _wrap_plscolbga, _wrap_plscolbga_texinfo ) {
21966 PLINT arg1 ;
21967 PLINT arg2 ;
21968 PLINT arg3 ;
21969 PLFLT arg4 ;
21970 int val1 ;
21971 int ecode1 = 0 ;
21972 int val2 ;
21973 int ecode2 = 0 ;
21974 int val3 ;
21975 int ecode3 = 0 ;
21976 double val4 ;
21977 int ecode4 = 0 ;
21978 octave_value_list _out;
21979 octave_value_list *_outp=&_out;
21980 octave_value _outv;
21981
21982 if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
21983 SWIG_fail;
21984 }
21985 ecode1 = SWIG_AsVal_int(args(0), &val1);
21986 if (!SWIG_IsOK(ecode1)) {
21987 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
21988 }
21989 arg1 = static_cast< PLINT >(val1);
21990 ecode2 = SWIG_AsVal_int(args(1), &val2);
21991 if (!SWIG_IsOK(ecode2)) {
21992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
21993 }
21994 arg2 = static_cast< PLINT >(val2);
21995 ecode3 = SWIG_AsVal_int(args(2), &val3);
21996 if (!SWIG_IsOK(ecode3)) {
21997 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
21998 }
21999 arg3 = static_cast< PLINT >(val3);
22000 ecode4 = SWIG_AsVal_double(args(3), &val4);
22001 if (!SWIG_IsOK(ecode4)) {
22002 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
22003 }
22004 arg4 = static_cast< PLFLT >(val4);
22005 plscolbga(arg1,arg2,arg3,arg4);
22006 _outv = octave_value();
22007 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22008 return _out;
22009 fail:
22010 return octave_value_list();
22011 }
22012
22013
22014 SWIG_DEFUN( plscolor, _wrap_plscolor, _wrap_plscolor_texinfo ) {
22015 PLINT arg1 ;
22016 int val1 ;
22017 int ecode1 = 0 ;
22018 octave_value_list _out;
22019 octave_value_list *_outp=&_out;
22020 octave_value _outv;
22021
22022 if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
22023 SWIG_fail;
22024 }
22025 ecode1 = SWIG_AsVal_int(args(0), &val1);
22026 if (!SWIG_IsOK(ecode1)) {
22027 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
22028 }
22029 arg1 = static_cast< PLINT >(val1);
22030 plscolor(arg1);
22031 _outv = octave_value();
22032 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22033 return _out;
22034 fail:
22035 return octave_value_list();
22036 }
22037
22038
22039 SWIG_DEFUN( plscompression, _wrap_plscompression, _wrap_plscompression_texinfo ) {
22040 PLINT arg1 ;
22041 int val1 ;
22042 int ecode1 = 0 ;
22043 octave_value_list _out;
22044 octave_value_list *_outp=&_out;
22045 octave_value _outv;
22046
22047 if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
22048 SWIG_fail;
22049 }
22050 ecode1 = SWIG_AsVal_int(args(0), &val1);
22051 if (!SWIG_IsOK(ecode1)) {
22052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
22053 }
22054 arg1 = static_cast< PLINT >(val1);
22055 plscompression(arg1);
22056 _outv = octave_value();
22057 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22058 return _out;
22059 fail:
22060 return octave_value_list();
22061 }
22062
22063
22064 SWIG_DEFUN( plsdev, _wrap_plsdev, _wrap_plsdev_texinfo ) {
22065 char *arg1 = (char *) 0 ;
22066 int res1 ;
22067 char *buf1 = 0 ;
22068 int alloc1 = 0 ;
22069 octave_value_list _out;
22070 octave_value_list *_outp=&_out;
22071 octave_value _outv;
22072
22073 if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
22074 SWIG_fail;
22075 }
22076 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22077 if (!SWIG_IsOK(res1)) {
22078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
22079 }
22080 arg1 = reinterpret_cast< char * >(buf1);
22081 plsdev((char const *)arg1);
22082 _outv = octave_value();
22083 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22084 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22085 return _out;
22086 fail:
22087 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22088 return octave_value_list();
22089 }
22090
22091
22092 SWIG_DEFUN( plsdidev, _wrap_plsdidev, _wrap_plsdidev_texinfo ) {
22093 PLFLT arg1 ;
22094 PLFLT arg2 ;
22095 PLFLT arg3 ;
22096 PLFLT arg4 ;
22097 double val1 ;
22098 int ecode1 = 0 ;
22099 double val2 ;
22100 int ecode2 = 0 ;
22101 double val3 ;
22102 int ecode3 = 0 ;
22103 double val4 ;
22104 int ecode4 = 0 ;
22105 octave_value_list _out;
22106 octave_value_list *_outp=&_out;
22107 octave_value _outv;
22108
22109 if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
22110 SWIG_fail;
22111 }
22112 ecode1 = SWIG_AsVal_double(args(0), &val1);
22113 if (!SWIG_IsOK(ecode1)) {
22114 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
22115 }
22116 arg1 = static_cast< PLFLT >(val1);
22117 ecode2 = SWIG_AsVal_double(args(1), &val2);
22118 if (!SWIG_IsOK(ecode2)) {
22119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
22120 }
22121 arg2 = static_cast< PLFLT >(val2);
22122 ecode3 = SWIG_AsVal_double(args(2), &val3);
22123 if (!SWIG_IsOK(ecode3)) {
22124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
22125 }
22126 arg3 = static_cast< PLFLT >(val3);
22127 ecode4 = SWIG_AsVal_double(args(3), &val4);
22128 if (!SWIG_IsOK(ecode4)) {
22129 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
22130 }
22131 arg4 = static_cast< PLFLT >(val4);
22132 plsdidev(arg1,arg2,arg3,arg4);
22133 _outv = octave_value();
22134 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22135 return _out;
22136 fail:
22137 return octave_value_list();
22138 }
22139
22140
22141 SWIG_DEFUN( plsdimap, _wrap_plsdimap, _wrap_plsdimap_texinfo ) {
22142 PLINT arg1 ;
22143 PLINT arg2 ;
22144 PLINT arg3 ;
22145 PLINT arg4 ;
22146 PLFLT arg5 ;
22147 PLFLT arg6 ;
22148 int val1 ;
22149 int ecode1 = 0 ;
22150 int val2 ;
22151 int ecode2 = 0 ;
22152 int val3 ;
22153 int ecode3 = 0 ;
22154 int val4 ;
22155 int ecode4 = 0 ;
22156 double val5 ;
22157 int ecode5 = 0 ;
22158 double val6 ;
22159 int ecode6 = 0 ;
22160 octave_value_list _out;
22161 octave_value_list *_outp=&_out;
22162 octave_value _outv;
22163
22164 if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
22165 SWIG_fail;
22166 }
22167 ecode1 = SWIG_AsVal_int(args(0), &val1);
22168 if (!SWIG_IsOK(ecode1)) {
22169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
22170 }
22171 arg1 = static_cast< PLINT >(val1);
22172 ecode2 = SWIG_AsVal_int(args(1), &val2);
22173 if (!SWIG_IsOK(ecode2)) {
22174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
22175 }
22176 arg2 = static_cast< PLINT >(val2);
22177 ecode3 = SWIG_AsVal_int(args(2), &val3);
22178 if (!SWIG_IsOK(ecode3)) {
22179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
22180 }
22181 arg3 = static_cast< PLINT >(val3);
22182 ecode4 = SWIG_AsVal_int(args(3), &val4);
22183 if (!SWIG_IsOK(ecode4)) {
22184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
22185 }
22186 arg4 = static_cast< PLINT >(val4);
22187 ecode5 = SWIG_AsVal_double(args(4), &val5);
22188 if (!SWIG_IsOK(ecode5)) {
22189 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
22190 }
22191 arg5 = static_cast< PLFLT >(val5);
22192 ecode6 = SWIG_AsVal_double(args(5), &val6);
22193 if (!SWIG_IsOK(ecode6)) {
22194 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
22195 }
22196 arg6 = static_cast< PLFLT >(val6);
22197 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
22198 _outv = octave_value();
22199 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22200 return _out;
22201 fail:
22202 return octave_value_list();
22203 }
22204
22205
22206 SWIG_DEFUN( plsdiori, _wrap_plsdiori, _wrap_plsdiori_texinfo ) {
22207 PLFLT arg1 ;
22208 double val1 ;
22209 int ecode1 = 0 ;
22210 octave_value_list _out;
22211 octave_value_list *_outp=&_out;
22212 octave_value _outv;
22213
22214 if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
22215 SWIG_fail;
22216 }
22217 ecode1 = SWIG_AsVal_double(args(0), &val1);
22218 if (!SWIG_IsOK(ecode1)) {
22219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
22220 }
22221 arg1 = static_cast< PLFLT >(val1);
22222 plsdiori(arg1);
22223 _outv = octave_value();
22224 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22225 return _out;
22226 fail:
22227 return octave_value_list();
22228 }
22229
22230
22231 SWIG_DEFUN( plsdiplt, _wrap_plsdiplt, _wrap_plsdiplt_texinfo ) {
22232 PLFLT arg1 ;
22233 PLFLT arg2 ;
22234 PLFLT arg3 ;
22235 PLFLT arg4 ;
22236 double val1 ;
22237 int ecode1 = 0 ;
22238 double val2 ;
22239 int ecode2 = 0 ;
22240 double val3 ;
22241 int ecode3 = 0 ;
22242 double val4 ;
22243 int ecode4 = 0 ;
22244 octave_value_list _out;
22245 octave_value_list *_outp=&_out;
22246 octave_value _outv;
22247
22248 if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
22249 SWIG_fail;
22250 }
22251 ecode1 = SWIG_AsVal_double(args(0), &val1);
22252 if (!SWIG_IsOK(ecode1)) {
22253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
22254 }
22255 arg1 = static_cast< PLFLT >(val1);
22256 ecode2 = SWIG_AsVal_double(args(1), &val2);
22257 if (!SWIG_IsOK(ecode2)) {
22258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
22259 }
22260 arg2 = static_cast< PLFLT >(val2);
22261 ecode3 = SWIG_AsVal_double(args(2), &val3);
22262 if (!SWIG_IsOK(ecode3)) {
22263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
22264 }
22265 arg3 = static_cast< PLFLT >(val3);
22266 ecode4 = SWIG_AsVal_double(args(3), &val4);
22267 if (!SWIG_IsOK(ecode4)) {
22268 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
22269 }
22270 arg4 = static_cast< PLFLT >(val4);
22271 plsdiplt(arg1,arg2,arg3,arg4);
22272 _outv = octave_value();
22273 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22274 return _out;
22275 fail:
22276 return octave_value_list();
22277 }
22278
22279
22280 SWIG_DEFUN( plsdiplz, _wrap_plsdiplz, _wrap_plsdiplz_texinfo ) {
22281 PLFLT arg1 ;
22282 PLFLT arg2 ;
22283 PLFLT arg3 ;
22284 PLFLT arg4 ;
22285 double val1 ;
22286 int ecode1 = 0 ;
22287 double val2 ;
22288 int ecode2 = 0 ;
22289 double val3 ;
22290 int ecode3 = 0 ;
22291 double val4 ;
22292 int ecode4 = 0 ;
22293 octave_value_list _out;
22294 octave_value_list *_outp=&_out;
22295 octave_value _outv;
22296
22297 if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
22298 SWIG_fail;
22299 }
22300 ecode1 = SWIG_AsVal_double(args(0), &val1);
22301 if (!SWIG_IsOK(ecode1)) {
22302 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
22303 }
22304 arg1 = static_cast< PLFLT >(val1);
22305 ecode2 = SWIG_AsVal_double(args(1), &val2);
22306 if (!SWIG_IsOK(ecode2)) {
22307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
22308 }
22309 arg2 = static_cast< PLFLT >(val2);
22310 ecode3 = SWIG_AsVal_double(args(2), &val3);
22311 if (!SWIG_IsOK(ecode3)) {
22312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
22313 }
22314 arg3 = static_cast< PLFLT >(val3);
22315 ecode4 = SWIG_AsVal_double(args(3), &val4);
22316 if (!SWIG_IsOK(ecode4)) {
22317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
22318 }
22319 arg4 = static_cast< PLFLT >(val4);
22320 plsdiplz(arg1,arg2,arg3,arg4);
22321 _outv = octave_value();
22322 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22323 return _out;
22324 fail:
22325 return octave_value_list();
22326 }
22327
22328
22329 SWIG_DEFUN( plseed, _wrap_plseed, _wrap_plseed_texinfo ) {
22330 unsigned int arg1 ;
22331 unsigned int val1 ;
22332 int ecode1 = 0 ;
22333 octave_value_list _out;
22334 octave_value_list *_outp=&_out;
22335 octave_value _outv;
22336
22337 if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
22338 SWIG_fail;
22339 }
22340 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
22341 if (!SWIG_IsOK(ecode1)) {
22342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
22343 }
22344 arg1 = static_cast< unsigned int >(val1);
22345 plseed(arg1);
22346 _outv = octave_value();
22347 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22348 return _out;
22349 fail:
22350 return octave_value_list();
22351 }
22352
22353
22354 SWIG_DEFUN( plsesc, _wrap_plsesc, _wrap_plsesc_texinfo ) {
22355 char arg1 ;
22356 char val1 ;
22357 int ecode1 = 0 ;
22358 octave_value_list _out;
22359 octave_value_list *_outp=&_out;
22360 octave_value _outv;
22361
22362 if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
22363 SWIG_fail;
22364 }
22365 ecode1 = SWIG_AsVal_char(args(0), &val1);
22366 if (!SWIG_IsOK(ecode1)) {
22367 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
22368 }
22369 arg1 = static_cast< char >(val1);
22370 plsesc(arg1);
22371 _outv = octave_value();
22372 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22373 return _out;
22374 fail:
22375 return octave_value_list();
22376 }
22377
22378
22379 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
22380 char *arg1 = (char *) 0 ;
22381 char *arg2 = (char *) 0 ;
22382 int res1 ;
22383 char *buf1 = 0 ;
22384 int alloc1 = 0 ;
22385 int res2 ;
22386 char *buf2 = 0 ;
22387 int alloc2 = 0 ;
22388 octave_value_list _out;
22389 octave_value_list *_outp=&_out;
22390 octave_value _outv;
22391 PLINT result;
22392
22393 if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
22394 SWIG_fail;
22395 }
22396 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22397 if (!SWIG_IsOK(res1)) {
22398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
22399 }
22400 arg1 = reinterpret_cast< char * >(buf1);
22401 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
22402 if (!SWIG_IsOK(res2)) {
22403 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
22404 }
22405 arg2 = reinterpret_cast< char * >(buf2);
22406 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
22407 _outv = SWIG_From_int(static_cast< int >(result));
22408 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22409 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22410 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22411 return _out;
22412 fail:
22413 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22414 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
22415 return octave_value_list();
22416 }
22417
22418
22419 SWIG_DEFUN( plsfam, _wrap_plsfam, _wrap_plsfam_texinfo ) {
22420 PLINT arg1 ;
22421 PLINT arg2 ;
22422 PLINT arg3 ;
22423 int val1 ;
22424 int ecode1 = 0 ;
22425 int val2 ;
22426 int ecode2 = 0 ;
22427 int val3 ;
22428 int ecode3 = 0 ;
22429 octave_value_list _out;
22430 octave_value_list *_outp=&_out;
22431 octave_value _outv;
22432
22433 if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
22434 SWIG_fail;
22435 }
22436 ecode1 = SWIG_AsVal_int(args(0), &val1);
22437 if (!SWIG_IsOK(ecode1)) {
22438 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
22439 }
22440 arg1 = static_cast< PLINT >(val1);
22441 ecode2 = SWIG_AsVal_int(args(1), &val2);
22442 if (!SWIG_IsOK(ecode2)) {
22443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
22444 }
22445 arg2 = static_cast< PLINT >(val2);
22446 ecode3 = SWIG_AsVal_int(args(2), &val3);
22447 if (!SWIG_IsOK(ecode3)) {
22448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
22449 }
22450 arg3 = static_cast< PLINT >(val3);
22451 plsfam(arg1,arg2,arg3);
22452 _outv = octave_value();
22453 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22454 return _out;
22455 fail:
22456 return octave_value_list();
22457 }
22458
22459
22460 SWIG_DEFUN( plsfci, _wrap_plsfci, _wrap_plsfci_texinfo ) {
22461 PLUNICODE arg1 ;
22462 unsigned int val1 ;
22463 int ecode1 = 0 ;
22464 octave_value_list _out;
22465 octave_value_list *_outp=&_out;
22466 octave_value _outv;
22467
22468 if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
22469 SWIG_fail;
22470 }
22471 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
22472 if (!SWIG_IsOK(ecode1)) {
22473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
22474 }
22475 arg1 = static_cast< PLUNICODE >(val1);
22476 plsfci(arg1);
22477 _outv = octave_value();
22478 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22479 return _out;
22480 fail:
22481 return octave_value_list();
22482 }
22483
22484
22485 SWIG_DEFUN( plsfnam, _wrap_plsfnam, _wrap_plsfnam_texinfo ) {
22486 char *arg1 = (char *) 0 ;
22487 int res1 ;
22488 char *buf1 = 0 ;
22489 int alloc1 = 0 ;
22490 octave_value_list _out;
22491 octave_value_list *_outp=&_out;
22492 octave_value _outv;
22493
22494 if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
22495 SWIG_fail;
22496 }
22497 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22498 if (!SWIG_IsOK(res1)) {
22499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
22500 }
22501 arg1 = reinterpret_cast< char * >(buf1);
22502 plsfnam((char const *)arg1);
22503 _outv = octave_value();
22504 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22505 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22506 return _out;
22507 fail:
22508 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22509 return octave_value_list();
22510 }
22511
22512
22513 SWIG_DEFUN( plsfont, _wrap_plsfont, _wrap_plsfont_texinfo ) {
22514 PLINT arg1 ;
22515 PLINT arg2 ;
22516 PLINT arg3 ;
22517 int val1 ;
22518 int ecode1 = 0 ;
22519 int val2 ;
22520 int ecode2 = 0 ;
22521 int val3 ;
22522 int ecode3 = 0 ;
22523 octave_value_list _out;
22524 octave_value_list *_outp=&_out;
22525 octave_value _outv;
22526
22527 if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
22528 SWIG_fail;
22529 }
22530 ecode1 = SWIG_AsVal_int(args(0), &val1);
22531 if (!SWIG_IsOK(ecode1)) {
22532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
22533 }
22534 arg1 = static_cast< PLINT >(val1);
22535 ecode2 = SWIG_AsVal_int(args(1), &val2);
22536 if (!SWIG_IsOK(ecode2)) {
22537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
22538 }
22539 arg2 = static_cast< PLINT >(val2);
22540 ecode3 = SWIG_AsVal_int(args(2), &val3);
22541 if (!SWIG_IsOK(ecode3)) {
22542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
22543 }
22544 arg3 = static_cast< PLINT >(val3);
22545 plsfont(arg1,arg2,arg3);
22546 _outv = octave_value();
22547 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22548 return _out;
22549 fail:
22550 return octave_value_list();
22551 }
22552
22553
22554 SWIG_DEFUN( plslabelfunc, _wrap_plslabelfunc, _wrap_plslabelfunc_texinfo ) {
22555 label_func arg1 = (label_func) 0 ;
22556 PLPointer arg2 = (PLPointer) 0 ;
22557 int res2 ;
22558 octave_value_list _out;
22559 octave_value_list *_outp=&_out;
22560 octave_value _outv;
22561
22562 if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
22563 SWIG_fail;
22564 }
22565 {
22566 octave_value obj = args(0);
22567 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
22568 if ( !obj.isempty() )
22569 #else
22570 if ( !obj.is_empty() )
22571 #endif
22572 {
22573 if ( obj.is_function_handle() || obj.is_inline_function() )
22574 {
22575 fcnLabelFunc = obj.function_value();
22576 }
22577 else if ( obj.is_string() )
22578 {
22579 nameLabelFunc = obj.string_value();
22580 fcnLabelFunc = NULL;
22581 }
22582 arg1 = labelfunc_octave;
22583 }
22584 else
22585 {
22586 arg1 = NULL;
22587 }
22588 }
22589 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
22590 if (!SWIG_IsOK(res2)) {
22591 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
22592 }
22593 plslabelfunc(arg1,arg2);
22594 _outv = octave_value();
22595 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22596 return _out;
22597 fail:
22598 return octave_value_list();
22599 }
22600
22601
22602 SWIG_DEFUN( plsmaj, _wrap_plsmaj, _wrap_plsmaj_texinfo ) {
22603 PLFLT arg1 ;
22604 PLFLT arg2 ;
22605 double val1 ;
22606 int ecode1 = 0 ;
22607 double val2 ;
22608 int ecode2 = 0 ;
22609 octave_value_list _out;
22610 octave_value_list *_outp=&_out;
22611 octave_value _outv;
22612
22613 if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
22614 SWIG_fail;
22615 }
22616 ecode1 = SWIG_AsVal_double(args(0), &val1);
22617 if (!SWIG_IsOK(ecode1)) {
22618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
22619 }
22620 arg1 = static_cast< PLFLT >(val1);
22621 ecode2 = SWIG_AsVal_double(args(1), &val2);
22622 if (!SWIG_IsOK(ecode2)) {
22623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
22624 }
22625 arg2 = static_cast< PLFLT >(val2);
22626 plsmaj(arg1,arg2);
22627 _outv = octave_value();
22628 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22629 return _out;
22630 fail:
22631 return octave_value_list();
22632 }
22633
22634
22635 SWIG_DEFUN( plsmin, _wrap_plsmin, _wrap_plsmin_texinfo ) {
22636 PLFLT arg1 ;
22637 PLFLT arg2 ;
22638 double val1 ;
22639 int ecode1 = 0 ;
22640 double val2 ;
22641 int ecode2 = 0 ;
22642 octave_value_list _out;
22643 octave_value_list *_outp=&_out;
22644 octave_value _outv;
22645
22646 if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
22647 SWIG_fail;
22648 }
22649 ecode1 = SWIG_AsVal_double(args(0), &val1);
22650 if (!SWIG_IsOK(ecode1)) {
22651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
22652 }
22653 arg1 = static_cast< PLFLT >(val1);
22654 ecode2 = SWIG_AsVal_double(args(1), &val2);
22655 if (!SWIG_IsOK(ecode2)) {
22656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
22657 }
22658 arg2 = static_cast< PLFLT >(val2);
22659 plsmin(arg1,arg2);
22660 _outv = octave_value();
22661 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22662 return _out;
22663 fail:
22664 return octave_value_list();
22665 }
22666
22667
22668 SWIG_DEFUN( plsori, _wrap_plsori, _wrap_plsori_texinfo ) {
22669 PLINT arg1 ;
22670 int val1 ;
22671 int ecode1 = 0 ;
22672 octave_value_list _out;
22673 octave_value_list *_outp=&_out;
22674 octave_value _outv;
22675
22676 if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
22677 SWIG_fail;
22678 }
22679 ecode1 = SWIG_AsVal_int(args(0), &val1);
22680 if (!SWIG_IsOK(ecode1)) {
22681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
22682 }
22683 arg1 = static_cast< PLINT >(val1);
22684 plsori(arg1);
22685 _outv = octave_value();
22686 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22687 return _out;
22688 fail:
22689 return octave_value_list();
22690 }
22691
22692
22693 SWIG_DEFUN( plspage, _wrap_plspage, _wrap_plspage_texinfo ) {
22694 PLFLT arg1 ;
22695 PLFLT arg2 ;
22696 PLINT arg3 ;
22697 PLINT arg4 ;
22698 PLINT arg5 ;
22699 PLINT arg6 ;
22700 double val1 ;
22701 int ecode1 = 0 ;
22702 double val2 ;
22703 int ecode2 = 0 ;
22704 int val3 ;
22705 int ecode3 = 0 ;
22706 int val4 ;
22707 int ecode4 = 0 ;
22708 int val5 ;
22709 int ecode5 = 0 ;
22710 int val6 ;
22711 int ecode6 = 0 ;
22712 octave_value_list _out;
22713 octave_value_list *_outp=&_out;
22714 octave_value _outv;
22715
22716 if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
22717 SWIG_fail;
22718 }
22719 ecode1 = SWIG_AsVal_double(args(0), &val1);
22720 if (!SWIG_IsOK(ecode1)) {
22721 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
22722 }
22723 arg1 = static_cast< PLFLT >(val1);
22724 ecode2 = SWIG_AsVal_double(args(1), &val2);
22725 if (!SWIG_IsOK(ecode2)) {
22726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
22727 }
22728 arg2 = static_cast< PLFLT >(val2);
22729 ecode3 = SWIG_AsVal_int(args(2), &val3);
22730 if (!SWIG_IsOK(ecode3)) {
22731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
22732 }
22733 arg3 = static_cast< PLINT >(val3);
22734 ecode4 = SWIG_AsVal_int(args(3), &val4);
22735 if (!SWIG_IsOK(ecode4)) {
22736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
22737 }
22738 arg4 = static_cast< PLINT >(val4);
22739 ecode5 = SWIG_AsVal_int(args(4), &val5);
22740 if (!SWIG_IsOK(ecode5)) {
22741 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
22742 }
22743 arg5 = static_cast< PLINT >(val5);
22744 ecode6 = SWIG_AsVal_int(args(5), &val6);
22745 if (!SWIG_IsOK(ecode6)) {
22746 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
22747 }
22748 arg6 = static_cast< PLINT >(val6);
22749 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
22750 _outv = octave_value();
22751 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22752 return _out;
22753 fail:
22754 return octave_value_list();
22755 }
22756
22757
22758 SWIG_DEFUN( plspal0, _wrap_plspal0, _wrap_plspal0_texinfo ) {
22759 char *arg1 = (char *) 0 ;
22760 int res1 ;
22761 char *buf1 = 0 ;
22762 int alloc1 = 0 ;
22763 octave_value_list _out;
22764 octave_value_list *_outp=&_out;
22765 octave_value _outv;
22766
22767 if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
22768 SWIG_fail;
22769 }
22770 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22771 if (!SWIG_IsOK(res1)) {
22772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
22773 }
22774 arg1 = reinterpret_cast< char * >(buf1);
22775 plspal0((char const *)arg1);
22776 _outv = octave_value();
22777 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22778 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22779 return _out;
22780 fail:
22781 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22782 return octave_value_list();
22783 }
22784
22785
22786 SWIG_DEFUN( plspal1, _wrap_plspal1, _wrap_plspal1_texinfo ) {
22787 char *arg1 = (char *) 0 ;
22788 PLBOOL arg2 ;
22789 int res1 ;
22790 char *buf1 = 0 ;
22791 int alloc1 = 0 ;
22792 int val2 ;
22793 int ecode2 = 0 ;
22794 octave_value_list _out;
22795 octave_value_list *_outp=&_out;
22796 octave_value _outv;
22797
22798 if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
22799 SWIG_fail;
22800 }
22801 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22802 if (!SWIG_IsOK(res1)) {
22803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
22804 }
22805 arg1 = reinterpret_cast< char * >(buf1);
22806 ecode2 = SWIG_AsVal_int(args(1), &val2);
22807 if (!SWIG_IsOK(ecode2)) {
22808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
22809 }
22810 arg2 = static_cast< PLBOOL >(val2);
22811 plspal1((char const *)arg1,arg2);
22812 _outv = octave_value();
22813 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22814 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22815 return _out;
22816 fail:
22817 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
22818 return octave_value_list();
22819 }
22820
22821
22822 SWIG_DEFUN( plspause, _wrap_plspause, _wrap_plspause_texinfo ) {
22823 PLBOOL arg1 ;
22824 int val1 ;
22825 int ecode1 = 0 ;
22826 octave_value_list _out;
22827 octave_value_list *_outp=&_out;
22828 octave_value _outv;
22829
22830 if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
22831 SWIG_fail;
22832 }
22833 ecode1 = SWIG_AsVal_int(args(0), &val1);
22834 if (!SWIG_IsOK(ecode1)) {
22835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
22836 }
22837 arg1 = static_cast< PLBOOL >(val1);
22838 plspause(arg1);
22839 _outv = octave_value();
22840 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22841 return _out;
22842 fail:
22843 return octave_value_list();
22844 }
22845
22846
22847 SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
22848 PLINT arg1 ;
22849 int val1 ;
22850 int ecode1 = 0 ;
22851 octave_value_list _out;
22852 octave_value_list *_outp=&_out;
22853 octave_value _outv;
22854
22855 if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
22856 SWIG_fail;
22857 }
22858 ecode1 = SWIG_AsVal_int(args(0), &val1);
22859 if (!SWIG_IsOK(ecode1)) {
22860 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
22861 }
22862 arg1 = static_cast< PLINT >(val1);
22863 plsstrm(arg1);
22864 _outv = octave_value();
22865 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22866 return _out;
22867 fail:
22868 return octave_value_list();
22869 }
22870
22871
22872 SWIG_DEFUN( plssub, _wrap_plssub, _wrap_plssub_texinfo ) {
22873 PLINT arg1 ;
22874 PLINT arg2 ;
22875 int val1 ;
22876 int ecode1 = 0 ;
22877 int val2 ;
22878 int ecode2 = 0 ;
22879 octave_value_list _out;
22880 octave_value_list *_outp=&_out;
22881 octave_value _outv;
22882
22883 if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
22884 SWIG_fail;
22885 }
22886 ecode1 = SWIG_AsVal_int(args(0), &val1);
22887 if (!SWIG_IsOK(ecode1)) {
22888 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
22889 }
22890 arg1 = static_cast< PLINT >(val1);
22891 ecode2 = SWIG_AsVal_int(args(1), &val2);
22892 if (!SWIG_IsOK(ecode2)) {
22893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
22894 }
22895 arg2 = static_cast< PLINT >(val2);
22896 plssub(arg1,arg2);
22897 _outv = octave_value();
22898 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22899 return _out;
22900 fail:
22901 return octave_value_list();
22902 }
22903
22904
22905 SWIG_DEFUN( plssym, _wrap_plssym, _wrap_plssym_texinfo ) {
22906 PLFLT arg1 ;
22907 PLFLT arg2 ;
22908 double val1 ;
22909 int ecode1 = 0 ;
22910 double val2 ;
22911 int ecode2 = 0 ;
22912 octave_value_list _out;
22913 octave_value_list *_outp=&_out;
22914 octave_value _outv;
22915
22916 if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
22917 SWIG_fail;
22918 }
22919 ecode1 = SWIG_AsVal_double(args(0), &val1);
22920 if (!SWIG_IsOK(ecode1)) {
22921 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
22922 }
22923 arg1 = static_cast< PLFLT >(val1);
22924 ecode2 = SWIG_AsVal_double(args(1), &val2);
22925 if (!SWIG_IsOK(ecode2)) {
22926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
22927 }
22928 arg2 = static_cast< PLFLT >(val2);
22929 plssym(arg1,arg2);
22930 _outv = octave_value();
22931 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22932 return _out;
22933 fail:
22934 return octave_value_list();
22935 }
22936
22937
22938 SWIG_DEFUN( plstar, _wrap_plstar, _wrap_plstar_texinfo ) {
22939 PLINT arg1 ;
22940 PLINT arg2 ;
22941 int val1 ;
22942 int ecode1 = 0 ;
22943 int val2 ;
22944 int ecode2 = 0 ;
22945 octave_value_list _out;
22946 octave_value_list *_outp=&_out;
22947 octave_value _outv;
22948
22949 if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
22950 SWIG_fail;
22951 }
22952 ecode1 = SWIG_AsVal_int(args(0), &val1);
22953 if (!SWIG_IsOK(ecode1)) {
22954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
22955 }
22956 arg1 = static_cast< PLINT >(val1);
22957 ecode2 = SWIG_AsVal_int(args(1), &val2);
22958 if (!SWIG_IsOK(ecode2)) {
22959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
22960 }
22961 arg2 = static_cast< PLINT >(val2);
22962 plstar(arg1,arg2);
22963 _outv = octave_value();
22964 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
22965 return _out;
22966 fail:
22967 return octave_value_list();
22968 }
22969
22970
22971 SWIG_DEFUN( plstart, _wrap_plstart, _wrap_plstart_texinfo ) {
22972 char *arg1 = (char *) 0 ;
22973 PLINT arg2 ;
22974 PLINT arg3 ;
22975 int res1 ;
22976 char *buf1 = 0 ;
22977 int alloc1 = 0 ;
22978 int val2 ;
22979 int ecode2 = 0 ;
22980 int val3 ;
22981 int ecode3 = 0 ;
22982 octave_value_list _out;
22983 octave_value_list *_outp=&_out;
22984 octave_value _outv;
22985
22986 if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
22987 SWIG_fail;
22988 }
22989 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
22990 if (!SWIG_IsOK(res1)) {
22991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
22992 }
22993 arg1 = reinterpret_cast< char * >(buf1);
22994 ecode2 = SWIG_AsVal_int(args(1), &val2);
22995 if (!SWIG_IsOK(ecode2)) {
22996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
22997 }
22998 arg2 = static_cast< PLINT >(val2);
22999 ecode3 = SWIG_AsVal_int(args(2), &val3);
23000 if (!SWIG_IsOK(ecode3)) {
23001 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
23002 }
23003 arg3 = static_cast< PLINT >(val3);
23004 plstart((char const *)arg1,arg2,arg3);
23005 _outv = octave_value();
23006 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23007 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23008 return _out;
23009 fail:
23010 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23011 return octave_value_list();
23012 }
23013
23014
23015 SWIG_DEFUN( plstransform, _wrap_plstransform, _wrap_plstransform_texinfo ) {
23016 ct_func arg1 = (ct_func) 0 ;
23017 PLPointer arg2 = (PLPointer) 0 ;
23018 int res2 ;
23019 octave_value_list _out;
23020 octave_value_list *_outp=&_out;
23021 octave_value _outv;
23022
23023 if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
23024 SWIG_fail;
23025 }
23026 {
23027 octave_value obj = args(0);
23028 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23029 if ( !obj.isempty() )
23030 #else
23031 if ( !obj.is_empty() )
23032 #endif
23033 {
23034 if ( obj.is_function_handle() || obj.is_inline_function() )
23035 {
23036 fcnCoordTrans = obj.function_value();
23037 }
23038 else if ( obj.is_string() )
23039 {
23040 nameCoordTrans = obj.string_value();
23041 fcnCoordTrans = NULL;
23042 }
23043 arg1 = ct_octave;
23044 }
23045 else
23046 {
23047 arg1 = NULL;
23048 }
23049 }
23050 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
23051 if (!SWIG_IsOK(res2)) {
23052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
23053 }
23054 plstransform(arg1,arg2);
23055 _outv = octave_value();
23056 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23057 return _out;
23058 fail:
23059 return octave_value_list();
23060 }
23061
23062
23063 SWIG_DEFUN( plstring, _wrap_plstring, _wrap_plstring_texinfo ) {
23064 PLINT arg1 ;
23065 PLFLT *arg2 = (PLFLT *) 0 ;
23066 PLFLT *arg3 = (PLFLT *) 0 ;
23067 char *arg4 = (char *) 0 ;
23068 Matrix temp1 ;
23069 Matrix temp3 ;
23070 int res4 ;
23071 char *buf4 = 0 ;
23072 int alloc4 = 0 ;
23073 octave_value_list _out;
23074 octave_value_list *_outp=&_out;
23075 octave_value _outv;
23076
23077 if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
23078 SWIG_fail;
23079 }
23080 {
23081 if ( _n_dims( args(0) ) > 1 )
23082 {
23083 error( "argument must be a scalar or vector" ); SWIG_fail;
23084 }
23085 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23086 temp1 = args(0).matrix_value();
23087 arg2 = &temp1( 0, 0 );
23088 }
23089 {
23090 if ( _n_dims( args(1) ) > 1 )
23091 {
23092 error( "argument must be a scalar or vector" ); SWIG_fail;
23093 }
23094 if ( _dim( args(1), 0 ) != Alen )
23095 {
23096 error( "argument vectors must be same length" ); SWIG_fail;
23097 }
23098 temp3 = args(1).matrix_value();
23099 arg3 = &temp3( 0, 0 );
23100 }
23101 res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
23102 if (!SWIG_IsOK(res4)) {
23103 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
23104 }
23105 arg4 = reinterpret_cast< char * >(buf4);
23106 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
23107 _outv = octave_value();
23108 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23109 {
23110
23111 }
23112 {
23113
23114 }
23115 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
23116 return _out;
23117 fail:
23118 {
23119
23120 }
23121 {
23122
23123 }
23124 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
23125 return octave_value_list();
23126 }
23127
23128
23129 SWIG_DEFUN( plstring3, _wrap_plstring3, _wrap_plstring3_texinfo ) {
23130 PLINT arg1 ;
23131 PLFLT *arg2 = (PLFLT *) 0 ;
23132 PLFLT *arg3 = (PLFLT *) 0 ;
23133 PLFLT *arg4 = (PLFLT *) 0 ;
23134 char *arg5 = (char *) 0 ;
23135 Matrix temp1 ;
23136 Matrix temp3 ;
23137 Matrix temp4 ;
23138 int res5 ;
23139 char *buf5 = 0 ;
23140 int alloc5 = 0 ;
23141 octave_value_list _out;
23142 octave_value_list *_outp=&_out;
23143 octave_value _outv;
23144
23145 if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
23146 SWIG_fail;
23147 }
23148 {
23149 if ( _n_dims( args(0) ) > 1 )
23150 {
23151 error( "argument must be a scalar or vector" ); SWIG_fail;
23152 }
23153 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23154 temp1 = args(0).matrix_value();
23155 arg2 = &temp1( 0, 0 );
23156 }
23157 {
23158 if ( _n_dims( args(1) ) > 1 )
23159 {
23160 error( "argument must be a scalar or vector" ); SWIG_fail;
23161 }
23162 if ( _dim( args(1), 0 ) != Alen )
23163 {
23164 error( "argument vectors must be same length" ); SWIG_fail;
23165 }
23166 temp3 = args(1).matrix_value();
23167 arg3 = &temp3( 0, 0 );
23168 }
23169 {
23170 if ( _n_dims( args(2) ) > 1 )
23171 {
23172 error( "argument must be a scalar or vector" ); SWIG_fail;
23173 }
23174 if ( _dim( args(2), 0 ) != Alen )
23175 {
23176 error( "argument vectors must be same length" ); SWIG_fail;
23177 }
23178 temp4 = args(2).matrix_value();
23179 arg4 = &temp4( 0, 0 );
23180 }
23181 res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
23182 if (!SWIG_IsOK(res5)) {
23183 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
23184 }
23185 arg5 = reinterpret_cast< char * >(buf5);
23186 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
23187 _outv = octave_value();
23188 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23189 {
23190
23191 }
23192 {
23193
23194 }
23195 {
23196
23197 }
23198 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
23199 return _out;
23200 fail:
23201 {
23202
23203 }
23204 {
23205
23206 }
23207 {
23208
23209 }
23210 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
23211 return octave_value_list();
23212 }
23213
23214
23215 SWIG_DEFUN( plstripa, _wrap_plstripa, _wrap_plstripa_texinfo ) {
23216 PLINT arg1 ;
23217 PLINT arg2 ;
23218 PLFLT arg3 ;
23219 PLFLT arg4 ;
23220 int val1 ;
23221 int ecode1 = 0 ;
23222 int val2 ;
23223 int ecode2 = 0 ;
23224 double val3 ;
23225 int ecode3 = 0 ;
23226 double val4 ;
23227 int ecode4 = 0 ;
23228 octave_value_list _out;
23229 octave_value_list *_outp=&_out;
23230 octave_value _outv;
23231
23232 if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
23233 SWIG_fail;
23234 }
23235 ecode1 = SWIG_AsVal_int(args(0), &val1);
23236 if (!SWIG_IsOK(ecode1)) {
23237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
23238 }
23239 arg1 = static_cast< PLINT >(val1);
23240 ecode2 = SWIG_AsVal_int(args(1), &val2);
23241 if (!SWIG_IsOK(ecode2)) {
23242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
23243 }
23244 arg2 = static_cast< PLINT >(val2);
23245 ecode3 = SWIG_AsVal_double(args(2), &val3);
23246 if (!SWIG_IsOK(ecode3)) {
23247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
23248 }
23249 arg3 = static_cast< PLFLT >(val3);
23250 ecode4 = SWIG_AsVal_double(args(3), &val4);
23251 if (!SWIG_IsOK(ecode4)) {
23252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
23253 }
23254 arg4 = static_cast< PLFLT >(val4);
23255 plstripa(arg1,arg2,arg3,arg4);
23256 _outv = octave_value();
23257 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23258 return _out;
23259 fail:
23260 return octave_value_list();
23261 }
23262
23263
23264 SWIG_DEFUN( plstripd, _wrap_plstripd, _wrap_plstripd_texinfo ) {
23265 PLINT arg1 ;
23266 int val1 ;
23267 int ecode1 = 0 ;
23268 octave_value_list _out;
23269 octave_value_list *_outp=&_out;
23270 octave_value _outv;
23271
23272 if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
23273 SWIG_fail;
23274 }
23275 ecode1 = SWIG_AsVal_int(args(0), &val1);
23276 if (!SWIG_IsOK(ecode1)) {
23277 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
23278 }
23279 arg1 = static_cast< PLINT >(val1);
23280 plstripd(arg1);
23281 _outv = octave_value();
23282 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23283 return _out;
23284 fail:
23285 return octave_value_list();
23286 }
23287
23288
23289 SWIG_DEFUN( plstyl, _wrap_plstyl, _wrap_plstyl_texinfo ) {
23290 PLINT arg1 ;
23291 PLINT *arg2 = (PLINT *) 0 ;
23292 PLINT *arg3 = (PLINT *) 0 ;
23293 Matrix temp1 ;
23294 Matrix temp3 ;
23295 octave_value_list _out;
23296 octave_value_list *_outp=&_out;
23297 octave_value _outv;
23298
23299 if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
23300 SWIG_fail;
23301 }
23302 {
23303 if ( _n_dims( args(0) ) > 1 )
23304 {
23305 error( "argument must be a scalar or vector" ); SWIG_fail;
23306 }
23307 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23308 arg2 = new PLINT[Alen];
23309 temp1 = args(0).matrix_value();
23310 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
23311 }
23312 {
23313 if ( _n_dims( args(1) ) > 1 )
23314 {
23315 error( "argument must be a scalar or vector" ); SWIG_fail;
23316 }
23317 if ( _dim( args(1), 0 ) != Alen )
23318 {
23319 error( "argument vectors must be same length" ); SWIG_fail;
23320 }
23321 temp3 = args(1).matrix_value();
23322 arg3 = new PLINT[Alen];
23323 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
23324 }
23325 plstyl(arg1,(int const *)arg2,(int const *)arg3);
23326 _outv = octave_value();
23327 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23328 {
23329 delete [] arg2;
23330 }
23331 {
23332 delete [] arg3;
23333 }
23334 return _out;
23335 fail:
23336 {
23337 delete [] arg2;
23338 }
23339 {
23340 delete [] arg3;
23341 }
23342 return octave_value_list();
23343 }
23344
23345
23346 SWIG_DEFUN( plsvect, _wrap_plsvect, _wrap_plsvect_texinfo ) {
23347 PLFLT *arg1 = (PLFLT *) 0 ;
23348 PLFLT *arg2 = (PLFLT *) 0 ;
23349 PLINT arg3 ;
23350 PLBOOL arg4 ;
23351 Matrix temp1 ;
23352 Matrix temp2 ;
23353 int val4 ;
23354 int ecode4 = 0 ;
23355 octave_value_list _out;
23356 octave_value_list *_outp=&_out;
23357 octave_value _outv;
23358
23359 if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
23360 SWIG_fail;
23361 }
23362 {
23363 if ( _n_dims( args(0) ) > 1 )
23364 {
23365 error( "argument must be a scalar or vector" ); SWIG_fail;
23366 }
23367 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23368 if ( !args(0).isempty() )
23369 #else
23370 if ( !args(0).is_empty() )
23371 #endif
23372 {
23373 Alen = (PLINT) ( _dim( args(0), 0 ) );
23374 temp1 = args(0).matrix_value();
23375 arg1 = &temp1( 0, 0 );
23376 }
23377 else
23378 {
23379 arg1 = NULL;
23380 Alen = 0;
23381 }
23382 }
23383 {
23384 if ( _n_dims( args(1) ) > 1 )
23385 {
23386 error( "argument must be a scalar or vector" ); SWIG_fail;
23387 }
23388 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
23389 if ( !args(1).isempty() )
23390 #else
23391 if ( !args(1).is_empty() )
23392 #endif
23393 {
23394 if ( _dim( args(1), 0 ) != Alen )
23395 {
23396 error( "argument vectors must be same length" ); SWIG_fail;
23397 }
23398 temp2 = args(1).matrix_value();
23399 arg2 = &temp2( 0, 0 );
23400 arg3 = (PLINT) ( _dim( args(1), 0 ) );
23401 }
23402 else
23403 {
23404 arg2 = NULL;
23405 arg3 = 0;
23406 }
23407 }
23408 ecode4 = SWIG_AsVal_int(args(2), &val4);
23409 if (!SWIG_IsOK(ecode4)) {
23410 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
23411 }
23412 arg4 = static_cast< PLBOOL >(val4);
23413 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
23414 _outv = octave_value();
23415 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23416 {
23417
23418 }
23419 {
23420
23421 }
23422 return _out;
23423 fail:
23424 {
23425
23426 }
23427 {
23428
23429 }
23430 return octave_value_list();
23431 }
23432
23433
23434 SWIG_DEFUN( plsvpa, _wrap_plsvpa, _wrap_plsvpa_texinfo ) {
23435 PLFLT arg1 ;
23436 PLFLT arg2 ;
23437 PLFLT arg3 ;
23438 PLFLT arg4 ;
23439 double val1 ;
23440 int ecode1 = 0 ;
23441 double val2 ;
23442 int ecode2 = 0 ;
23443 double val3 ;
23444 int ecode3 = 0 ;
23445 double val4 ;
23446 int ecode4 = 0 ;
23447 octave_value_list _out;
23448 octave_value_list *_outp=&_out;
23449 octave_value _outv;
23450
23451 if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
23452 SWIG_fail;
23453 }
23454 ecode1 = SWIG_AsVal_double(args(0), &val1);
23455 if (!SWIG_IsOK(ecode1)) {
23456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
23457 }
23458 arg1 = static_cast< PLFLT >(val1);
23459 ecode2 = SWIG_AsVal_double(args(1), &val2);
23460 if (!SWIG_IsOK(ecode2)) {
23461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
23462 }
23463 arg2 = static_cast< PLFLT >(val2);
23464 ecode3 = SWIG_AsVal_double(args(2), &val3);
23465 if (!SWIG_IsOK(ecode3)) {
23466 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
23467 }
23468 arg3 = static_cast< PLFLT >(val3);
23469 ecode4 = SWIG_AsVal_double(args(3), &val4);
23470 if (!SWIG_IsOK(ecode4)) {
23471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
23472 }
23473 arg4 = static_cast< PLFLT >(val4);
23474 plsvpa(arg1,arg2,arg3,arg4);
23475 _outv = octave_value();
23476 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23477 return _out;
23478 fail:
23479 return octave_value_list();
23480 }
23481
23482
23483 SWIG_DEFUN( plsxax, _wrap_plsxax, _wrap_plsxax_texinfo ) {
23484 PLINT arg1 ;
23485 PLINT arg2 ;
23486 int val1 ;
23487 int ecode1 = 0 ;
23488 int val2 ;
23489 int ecode2 = 0 ;
23490 octave_value_list _out;
23491 octave_value_list *_outp=&_out;
23492 octave_value _outv;
23493
23494 if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
23495 SWIG_fail;
23496 }
23497 ecode1 = SWIG_AsVal_int(args(0), &val1);
23498 if (!SWIG_IsOK(ecode1)) {
23499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
23500 }
23501 arg1 = static_cast< PLINT >(val1);
23502 ecode2 = SWIG_AsVal_int(args(1), &val2);
23503 if (!SWIG_IsOK(ecode2)) {
23504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
23505 }
23506 arg2 = static_cast< PLINT >(val2);
23507 plsxax(arg1,arg2);
23508 _outv = octave_value();
23509 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23510 return _out;
23511 fail:
23512 return octave_value_list();
23513 }
23514
23515
23516 SWIG_DEFUN( plsyax, _wrap_plsyax, _wrap_plsyax_texinfo ) {
23517 PLINT arg1 ;
23518 PLINT arg2 ;
23519 int val1 ;
23520 int ecode1 = 0 ;
23521 int val2 ;
23522 int ecode2 = 0 ;
23523 octave_value_list _out;
23524 octave_value_list *_outp=&_out;
23525 octave_value _outv;
23526
23527 if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
23528 SWIG_fail;
23529 }
23530 ecode1 = SWIG_AsVal_int(args(0), &val1);
23531 if (!SWIG_IsOK(ecode1)) {
23532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
23533 }
23534 arg1 = static_cast< PLINT >(val1);
23535 ecode2 = SWIG_AsVal_int(args(1), &val2);
23536 if (!SWIG_IsOK(ecode2)) {
23537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
23538 }
23539 arg2 = static_cast< PLINT >(val2);
23540 plsyax(arg1,arg2);
23541 _outv = octave_value();
23542 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23543 return _out;
23544 fail:
23545 return octave_value_list();
23546 }
23547
23548
23549 SWIG_DEFUN( plsym, _wrap_plsym, _wrap_plsym_texinfo ) {
23550 PLINT arg1 ;
23551 PLFLT *arg2 = (PLFLT *) 0 ;
23552 PLFLT *arg3 = (PLFLT *) 0 ;
23553 PLINT arg4 ;
23554 Matrix temp1 ;
23555 Matrix temp3 ;
23556 int val4 ;
23557 int ecode4 = 0 ;
23558 octave_value_list _out;
23559 octave_value_list *_outp=&_out;
23560 octave_value _outv;
23561
23562 if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
23563 SWIG_fail;
23564 }
23565 {
23566 if ( _n_dims( args(0) ) > 1 )
23567 {
23568 error( "argument must be a scalar or vector" ); SWIG_fail;
23569 }
23570 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
23571 temp1 = args(0).matrix_value();
23572 arg2 = &temp1( 0, 0 );
23573 }
23574 {
23575 if ( _n_dims( args(1) ) > 1 )
23576 {
23577 error( "argument must be a scalar or vector" ); SWIG_fail;
23578 }
23579 if ( _dim( args(1), 0 ) != Alen )
23580 {
23581 error( "argument vectors must be same length" ); SWIG_fail;
23582 }
23583 temp3 = args(1).matrix_value();
23584 arg3 = &temp3( 0, 0 );
23585 }
23586 ecode4 = SWIG_AsVal_int(args(2), &val4);
23587 if (!SWIG_IsOK(ecode4)) {
23588 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
23589 }
23590 arg4 = static_cast< PLINT >(val4);
23591 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
23592 _outv = octave_value();
23593 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23594 {
23595
23596 }
23597 {
23598
23599 }
23600 return _out;
23601 fail:
23602 {
23603
23604 }
23605 {
23606
23607 }
23608 return octave_value_list();
23609 }
23610
23611
23612 SWIG_DEFUN( plszax, _wrap_plszax, _wrap_plszax_texinfo ) {
23613 PLINT arg1 ;
23614 PLINT arg2 ;
23615 int val1 ;
23616 int ecode1 = 0 ;
23617 int val2 ;
23618 int ecode2 = 0 ;
23619 octave_value_list _out;
23620 octave_value_list *_outp=&_out;
23621 octave_value _outv;
23622
23623 if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
23624 SWIG_fail;
23625 }
23626 ecode1 = SWIG_AsVal_int(args(0), &val1);
23627 if (!SWIG_IsOK(ecode1)) {
23628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
23629 }
23630 arg1 = static_cast< PLINT >(val1);
23631 ecode2 = SWIG_AsVal_int(args(1), &val2);
23632 if (!SWIG_IsOK(ecode2)) {
23633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
23634 }
23635 arg2 = static_cast< PLINT >(val2);
23636 plszax(arg1,arg2);
23637 _outv = octave_value();
23638 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23639 return _out;
23640 fail:
23641 return octave_value_list();
23642 }
23643
23644
23645 SWIG_DEFUN( pltext, _wrap_pltext, _wrap_pltext_texinfo ) {
23646 octave_value_list _out;
23647 octave_value_list *_outp=&_out;
23648 octave_value _outv;
23649
23650 if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
23651 SWIG_fail;
23652 }
23653 pltext();
23654 _outv = octave_value();
23655 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23656 return _out;
23657 fail:
23658 return octave_value_list();
23659 }
23660
23661
23662 SWIG_DEFUN( pltimefmt, _wrap_pltimefmt, _wrap_pltimefmt_texinfo ) {
23663 char *arg1 = (char *) 0 ;
23664 int res1 ;
23665 char *buf1 = 0 ;
23666 int alloc1 = 0 ;
23667 octave_value_list _out;
23668 octave_value_list *_outp=&_out;
23669 octave_value _outv;
23670
23671 if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
23672 SWIG_fail;
23673 }
23674 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
23675 if (!SWIG_IsOK(res1)) {
23676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
23677 }
23678 arg1 = reinterpret_cast< char * >(buf1);
23679 pltimefmt((char const *)arg1);
23680 _outv = octave_value();
23681 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23682 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23683 return _out;
23684 fail:
23685 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
23686 return octave_value_list();
23687 }
23688
23689
23690 SWIG_DEFUN( plvasp, _wrap_plvasp, _wrap_plvasp_texinfo ) {
23691 PLFLT arg1 ;
23692 double val1 ;
23693 int ecode1 = 0 ;
23694 octave_value_list _out;
23695 octave_value_list *_outp=&_out;
23696 octave_value _outv;
23697
23698 if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
23699 SWIG_fail;
23700 }
23701 ecode1 = SWIG_AsVal_double(args(0), &val1);
23702 if (!SWIG_IsOK(ecode1)) {
23703 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
23704 }
23705 arg1 = static_cast< PLFLT >(val1);
23706 plvasp(arg1);
23707 _outv = octave_value();
23708 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23709 return _out;
23710 fail:
23711 return octave_value_list();
23712 }
23713
23714
23715 SWIG_DEFUN( plvpas, _wrap_plvpas, _wrap_plvpas_texinfo ) {
23716 PLFLT arg1 ;
23717 PLFLT arg2 ;
23718 PLFLT arg3 ;
23719 PLFLT arg4 ;
23720 PLFLT arg5 ;
23721 double val1 ;
23722 int ecode1 = 0 ;
23723 double val2 ;
23724 int ecode2 = 0 ;
23725 double val3 ;
23726 int ecode3 = 0 ;
23727 double val4 ;
23728 int ecode4 = 0 ;
23729 double val5 ;
23730 int ecode5 = 0 ;
23731 octave_value_list _out;
23732 octave_value_list *_outp=&_out;
23733 octave_value _outv;
23734
23735 if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
23736 SWIG_fail;
23737 }
23738 ecode1 = SWIG_AsVal_double(args(0), &val1);
23739 if (!SWIG_IsOK(ecode1)) {
23740 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
23741 }
23742 arg1 = static_cast< PLFLT >(val1);
23743 ecode2 = SWIG_AsVal_double(args(1), &val2);
23744 if (!SWIG_IsOK(ecode2)) {
23745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
23746 }
23747 arg2 = static_cast< PLFLT >(val2);
23748 ecode3 = SWIG_AsVal_double(args(2), &val3);
23749 if (!SWIG_IsOK(ecode3)) {
23750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
23751 }
23752 arg3 = static_cast< PLFLT >(val3);
23753 ecode4 = SWIG_AsVal_double(args(3), &val4);
23754 if (!SWIG_IsOK(ecode4)) {
23755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
23756 }
23757 arg4 = static_cast< PLFLT >(val4);
23758 ecode5 = SWIG_AsVal_double(args(4), &val5);
23759 if (!SWIG_IsOK(ecode5)) {
23760 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
23761 }
23762 arg5 = static_cast< PLFLT >(val5);
23763 plvpas(arg1,arg2,arg3,arg4,arg5);
23764 _outv = octave_value();
23765 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23766 return _out;
23767 fail:
23768 return octave_value_list();
23769 }
23770
23771
23772 SWIG_DEFUN( plvpor, _wrap_plvpor, _wrap_plvpor_texinfo ) {
23773 PLFLT arg1 ;
23774 PLFLT arg2 ;
23775 PLFLT arg3 ;
23776 PLFLT arg4 ;
23777 double val1 ;
23778 int ecode1 = 0 ;
23779 double val2 ;
23780 int ecode2 = 0 ;
23781 double val3 ;
23782 int ecode3 = 0 ;
23783 double val4 ;
23784 int ecode4 = 0 ;
23785 octave_value_list _out;
23786 octave_value_list *_outp=&_out;
23787 octave_value _outv;
23788
23789 if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
23790 SWIG_fail;
23791 }
23792 ecode1 = SWIG_AsVal_double(args(0), &val1);
23793 if (!SWIG_IsOK(ecode1)) {
23794 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
23795 }
23796 arg1 = static_cast< PLFLT >(val1);
23797 ecode2 = SWIG_AsVal_double(args(1), &val2);
23798 if (!SWIG_IsOK(ecode2)) {
23799 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
23800 }
23801 arg2 = static_cast< PLFLT >(val2);
23802 ecode3 = SWIG_AsVal_double(args(2), &val3);
23803 if (!SWIG_IsOK(ecode3)) {
23804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
23805 }
23806 arg3 = static_cast< PLFLT >(val3);
23807 ecode4 = SWIG_AsVal_double(args(3), &val4);
23808 if (!SWIG_IsOK(ecode4)) {
23809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
23810 }
23811 arg4 = static_cast< PLFLT >(val4);
23812 plvpor(arg1,arg2,arg3,arg4);
23813 _outv = octave_value();
23814 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23815 return _out;
23816 fail:
23817 return octave_value_list();
23818 }
23819
23820
23821 SWIG_DEFUN( plvsta, _wrap_plvsta, _wrap_plvsta_texinfo ) {
23822 octave_value_list _out;
23823 octave_value_list *_outp=&_out;
23824 octave_value _outv;
23825
23826 if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
23827 SWIG_fail;
23828 }
23829 plvsta();
23830 _outv = octave_value();
23831 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23832 return _out;
23833 fail:
23834 return octave_value_list();
23835 }
23836
23837
23838 SWIG_DEFUN( plw3d, _wrap_plw3d, _wrap_plw3d_texinfo ) {
23839 PLFLT arg1 ;
23840 PLFLT arg2 ;
23841 PLFLT arg3 ;
23842 PLFLT arg4 ;
23843 PLFLT arg5 ;
23844 PLFLT arg6 ;
23845 PLFLT arg7 ;
23846 PLFLT arg8 ;
23847 PLFLT arg9 ;
23848 PLFLT arg10 ;
23849 PLFLT arg11 ;
23850 double val1 ;
23851 int ecode1 = 0 ;
23852 double val2 ;
23853 int ecode2 = 0 ;
23854 double val3 ;
23855 int ecode3 = 0 ;
23856 double val4 ;
23857 int ecode4 = 0 ;
23858 double val5 ;
23859 int ecode5 = 0 ;
23860 double val6 ;
23861 int ecode6 = 0 ;
23862 double val7 ;
23863 int ecode7 = 0 ;
23864 double val8 ;
23865 int ecode8 = 0 ;
23866 double val9 ;
23867 int ecode9 = 0 ;
23868 double val10 ;
23869 int ecode10 = 0 ;
23870 double val11 ;
23871 int ecode11 = 0 ;
23872 octave_value_list _out;
23873 octave_value_list *_outp=&_out;
23874 octave_value _outv;
23875
23876 if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
23877 SWIG_fail;
23878 }
23879 ecode1 = SWIG_AsVal_double(args(0), &val1);
23880 if (!SWIG_IsOK(ecode1)) {
23881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
23882 }
23883 arg1 = static_cast< PLFLT >(val1);
23884 ecode2 = SWIG_AsVal_double(args(1), &val2);
23885 if (!SWIG_IsOK(ecode2)) {
23886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
23887 }
23888 arg2 = static_cast< PLFLT >(val2);
23889 ecode3 = SWIG_AsVal_double(args(2), &val3);
23890 if (!SWIG_IsOK(ecode3)) {
23891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
23892 }
23893 arg3 = static_cast< PLFLT >(val3);
23894 ecode4 = SWIG_AsVal_double(args(3), &val4);
23895 if (!SWIG_IsOK(ecode4)) {
23896 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
23897 }
23898 arg4 = static_cast< PLFLT >(val4);
23899 ecode5 = SWIG_AsVal_double(args(4), &val5);
23900 if (!SWIG_IsOK(ecode5)) {
23901 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
23902 }
23903 arg5 = static_cast< PLFLT >(val5);
23904 ecode6 = SWIG_AsVal_double(args(5), &val6);
23905 if (!SWIG_IsOK(ecode6)) {
23906 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
23907 }
23908 arg6 = static_cast< PLFLT >(val6);
23909 ecode7 = SWIG_AsVal_double(args(6), &val7);
23910 if (!SWIG_IsOK(ecode7)) {
23911 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
23912 }
23913 arg7 = static_cast< PLFLT >(val7);
23914 ecode8 = SWIG_AsVal_double(args(7), &val8);
23915 if (!SWIG_IsOK(ecode8)) {
23916 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
23917 }
23918 arg8 = static_cast< PLFLT >(val8);
23919 ecode9 = SWIG_AsVal_double(args(8), &val9);
23920 if (!SWIG_IsOK(ecode9)) {
23921 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
23922 }
23923 arg9 = static_cast< PLFLT >(val9);
23924 ecode10 = SWIG_AsVal_double(args(9), &val10);
23925 if (!SWIG_IsOK(ecode10)) {
23926 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
23927 }
23928 arg10 = static_cast< PLFLT >(val10);
23929 ecode11 = SWIG_AsVal_double(args(10), &val11);
23930 if (!SWIG_IsOK(ecode11)) {
23931 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
23932 }
23933 arg11 = static_cast< PLFLT >(val11);
23934 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
23935 _outv = octave_value();
23936 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23937 return _out;
23938 fail:
23939 return octave_value_list();
23940 }
23941
23942
23943 SWIG_DEFUN( plwidth, _wrap_plwidth, _wrap_plwidth_texinfo ) {
23944 PLFLT arg1 ;
23945 double val1 ;
23946 int ecode1 = 0 ;
23947 octave_value_list _out;
23948 octave_value_list *_outp=&_out;
23949 octave_value _outv;
23950
23951 if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
23952 SWIG_fail;
23953 }
23954 ecode1 = SWIG_AsVal_double(args(0), &val1);
23955 if (!SWIG_IsOK(ecode1)) {
23956 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLFLT""'");
23957 }
23958 arg1 = static_cast< PLFLT >(val1);
23959 plwidth(arg1);
23960 _outv = octave_value();
23961 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
23962 return _out;
23963 fail:
23964 return octave_value_list();
23965 }
23966
23967
23968 SWIG_DEFUN( plwind, _wrap_plwind, _wrap_plwind_texinfo ) {
23969 PLFLT arg1 ;
23970 PLFLT arg2 ;
23971 PLFLT arg3 ;
23972 PLFLT arg4 ;
23973 double val1 ;
23974 int ecode1 = 0 ;
23975 double val2 ;
23976 int ecode2 = 0 ;
23977 double val3 ;
23978 int ecode3 = 0 ;
23979 double val4 ;
23980 int ecode4 = 0 ;
23981 octave_value_list _out;
23982 octave_value_list *_outp=&_out;
23983 octave_value _outv;
23984
23985 if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
23986 SWIG_fail;
23987 }
23988 ecode1 = SWIG_AsVal_double(args(0), &val1);
23989 if (!SWIG_IsOK(ecode1)) {
23990 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
23991 }
23992 arg1 = static_cast< PLFLT >(val1);
23993 ecode2 = SWIG_AsVal_double(args(1), &val2);
23994 if (!SWIG_IsOK(ecode2)) {
23995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
23996 }
23997 arg2 = static_cast< PLFLT >(val2);
23998 ecode3 = SWIG_AsVal_double(args(2), &val3);
23999 if (!SWIG_IsOK(ecode3)) {
24000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
24001 }
24002 arg3 = static_cast< PLFLT >(val3);
24003 ecode4 = SWIG_AsVal_double(args(3), &val4);
24004 if (!SWIG_IsOK(ecode4)) {
24005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
24006 }
24007 arg4 = static_cast< PLFLT >(val4);
24008 plwind(arg1,arg2,arg3,arg4);
24009 _outv = octave_value();
24010 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24011 return _out;
24012 fail:
24013 return octave_value_list();
24014 }
24015
24016
24017 SWIG_DEFUN( plxormod, _wrap_plxormod, _wrap_plxormod_texinfo ) {
24018 PLBOOL arg1 ;
24019 PLBOOL *arg2 = (PLBOOL *) 0 ;
24020 int val1 ;
24021 int ecode1 = 0 ;
24022 PLBOOL temp2 ;
24023 int res2 = SWIG_TMPOBJ ;
24024 octave_value_list _out;
24025 octave_value_list *_outp=&_out;
24026 octave_value _outv;
24027
24028 arg2 = &temp2;
24029 if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
24030 SWIG_fail;
24031 }
24032 ecode1 = SWIG_AsVal_int(args(0), &val1);
24033 if (!SWIG_IsOK(ecode1)) {
24034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
24035 }
24036 arg1 = static_cast< PLBOOL >(val1);
24037 plxormod(arg1,arg2);
24038 _outv = octave_value();
24039 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24040 if (SWIG_IsTmpObj(res2)) {
24041 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
24042 } else {
24043 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24044 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
24045 }
24046 return _out;
24047 fail:
24048 return octave_value_list();
24049 }
24050
24051
24052 SWIG_DEFUN( plmap, _wrap_plmap, _wrap_plmap_texinfo ) {
24053 mapform_func arg1 = (mapform_func) 0 ;
24054 char *arg2 = (char *) 0 ;
24055 PLFLT arg3 ;
24056 PLFLT arg4 ;
24057 PLFLT arg5 ;
24058 PLFLT arg6 ;
24059 int res2 ;
24060 char *buf2 = 0 ;
24061 int alloc2 = 0 ;
24062 double val3 ;
24063 int ecode3 = 0 ;
24064 double val4 ;
24065 int ecode4 = 0 ;
24066 double val5 ;
24067 int ecode5 = 0 ;
24068 double val6 ;
24069 int ecode6 = 0 ;
24070 octave_value_list _out;
24071 octave_value_list *_outp=&_out;
24072 octave_value _outv;
24073
24074 if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
24075 SWIG_fail;
24076 }
24077 {
24078 octave_value obj = args(0);
24079 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24080 if ( !obj.isempty() )
24081 #else
24082 if ( !obj.is_empty() )
24083 #endif
24084 {
24085 if ( obj.is_function_handle() || obj.is_inline_function() )
24086 {
24087 fcnMapForm = obj.function_value();
24088 }
24089 else if ( obj.is_string() )
24090 {
24091 nameMapForm = obj.string_value();
24092 fcnMapForm = NULL;
24093 }
24094 arg1 = mapform_octave;
24095 }
24096 else
24097 {
24098 arg1 = NULL;
24099 }
24100 }
24101 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24102 if (!SWIG_IsOK(res2)) {
24103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
24104 }
24105 arg2 = reinterpret_cast< char * >(buf2);
24106 ecode3 = SWIG_AsVal_double(args(2), &val3);
24107 if (!SWIG_IsOK(ecode3)) {
24108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
24109 }
24110 arg3 = static_cast< PLFLT >(val3);
24111 ecode4 = SWIG_AsVal_double(args(3), &val4);
24112 if (!SWIG_IsOK(ecode4)) {
24113 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
24114 }
24115 arg4 = static_cast< PLFLT >(val4);
24116 ecode5 = SWIG_AsVal_double(args(4), &val5);
24117 if (!SWIG_IsOK(ecode5)) {
24118 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
24119 }
24120 arg5 = static_cast< PLFLT >(val5);
24121 ecode6 = SWIG_AsVal_double(args(5), &val6);
24122 if (!SWIG_IsOK(ecode6)) {
24123 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
24124 }
24125 arg6 = static_cast< PLFLT >(val6);
24126 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
24127 _outv = octave_value();
24128 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24129 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24130 return _out;
24131 fail:
24132 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24133 return octave_value_list();
24134 }
24135
24136
24137 SWIG_DEFUN( plmapline, _wrap_plmapline, _wrap_plmapline_texinfo ) {
24138 mapform_func arg1 = (mapform_func) 0 ;
24139 char *arg2 = (char *) 0 ;
24140 PLFLT arg3 ;
24141 PLFLT arg4 ;
24142 PLFLT arg5 ;
24143 PLFLT arg6 ;
24144 PLINT *arg7 = (PLINT *) 0 ;
24145 PLINT arg8 ;
24146 int res2 ;
24147 char *buf2 = 0 ;
24148 int alloc2 = 0 ;
24149 double val3 ;
24150 int ecode3 = 0 ;
24151 double val4 ;
24152 int ecode4 = 0 ;
24153 double val5 ;
24154 int ecode5 = 0 ;
24155 double val6 ;
24156 int ecode6 = 0 ;
24157 Matrix temp7 ;
24158 octave_value_list _out;
24159 octave_value_list *_outp=&_out;
24160 octave_value _outv;
24161
24162 if (!SWIG_check_num_args("plmapline",args.length(),7,7,0)) {
24163 SWIG_fail;
24164 }
24165 {
24166 octave_value obj = args(0);
24167 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24168 if ( !obj.isempty() )
24169 #else
24170 if ( !obj.is_empty() )
24171 #endif
24172 {
24173 if ( obj.is_function_handle() || obj.is_inline_function() )
24174 {
24175 fcnMapForm = obj.function_value();
24176 }
24177 else if ( obj.is_string() )
24178 {
24179 nameMapForm = obj.string_value();
24180 fcnMapForm = NULL;
24181 }
24182 arg1 = mapform_octave;
24183 }
24184 else
24185 {
24186 arg1 = NULL;
24187 }
24188 }
24189 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24190 if (!SWIG_IsOK(res2)) {
24191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapline" "', argument " "2"" of type '" "char const *""'");
24192 }
24193 arg2 = reinterpret_cast< char * >(buf2);
24194 ecode3 = SWIG_AsVal_double(args(2), &val3);
24195 if (!SWIG_IsOK(ecode3)) {
24196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapline" "', argument " "3"" of type '" "PLFLT""'");
24197 }
24198 arg3 = static_cast< PLFLT >(val3);
24199 ecode4 = SWIG_AsVal_double(args(3), &val4);
24200 if (!SWIG_IsOK(ecode4)) {
24201 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapline" "', argument " "4"" of type '" "PLFLT""'");
24202 }
24203 arg4 = static_cast< PLFLT >(val4);
24204 ecode5 = SWIG_AsVal_double(args(4), &val5);
24205 if (!SWIG_IsOK(ecode5)) {
24206 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapline" "', argument " "5"" of type '" "PLFLT""'");
24207 }
24208 arg5 = static_cast< PLFLT >(val5);
24209 ecode6 = SWIG_AsVal_double(args(5), &val6);
24210 if (!SWIG_IsOK(ecode6)) {
24211 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapline" "', argument " "6"" of type '" "PLFLT""'");
24212 }
24213 arg6 = static_cast< PLFLT >(val6);
24214 {
24215 if ( _n_dims( args(6) ) > 1 )
24216 {
24217 error( "argument must be a scalar or vector" ); SWIG_fail;
24218 }
24219 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24220 if ( !args(6).isempty() )
24221 #else
24222 if ( !args(6).is_empty() )
24223 #endif
24224 {
24225 arg8 = (PLINT) ( _dim( args(6), 0 ) );
24226 temp7 = args(6).matrix_value();
24227 arg7 = new PLINT[arg8];
24228 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
24229 }
24230 else
24231 {
24232 arg7 = NULL;
24233 arg8 = 0;
24234 }
24235 }
24236 plmapline(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
24237 _outv = octave_value();
24238 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24239 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24240 {
24241 delete [] arg7;
24242 }
24243 return _out;
24244 fail:
24245 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24246 {
24247 delete [] arg7;
24248 }
24249 return octave_value_list();
24250 }
24251
24252
24253 SWIG_DEFUN( plmapstring, _wrap_plmapstring, _wrap_plmapstring_texinfo ) {
24254 mapform_func arg1 = (mapform_func) 0 ;
24255 char *arg2 = (char *) 0 ;
24256 char *arg3 = (char *) 0 ;
24257 PLFLT arg4 ;
24258 PLFLT arg5 ;
24259 PLFLT arg6 ;
24260 PLFLT arg7 ;
24261 PLINT *arg8 = (PLINT *) 0 ;
24262 PLINT arg9 ;
24263 int res2 ;
24264 char *buf2 = 0 ;
24265 int alloc2 = 0 ;
24266 int res3 ;
24267 char *buf3 = 0 ;
24268 int alloc3 = 0 ;
24269 double val4 ;
24270 int ecode4 = 0 ;
24271 double val5 ;
24272 int ecode5 = 0 ;
24273 double val6 ;
24274 int ecode6 = 0 ;
24275 double val7 ;
24276 int ecode7 = 0 ;
24277 Matrix temp8 ;
24278 octave_value_list _out;
24279 octave_value_list *_outp=&_out;
24280 octave_value _outv;
24281
24282 if (!SWIG_check_num_args("plmapstring",args.length(),8,8,0)) {
24283 SWIG_fail;
24284 }
24285 {
24286 octave_value obj = args(0);
24287 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24288 if ( !obj.isempty() )
24289 #else
24290 if ( !obj.is_empty() )
24291 #endif
24292 {
24293 if ( obj.is_function_handle() || obj.is_inline_function() )
24294 {
24295 fcnMapForm = obj.function_value();
24296 }
24297 else if ( obj.is_string() )
24298 {
24299 nameMapForm = obj.string_value();
24300 fcnMapForm = NULL;
24301 }
24302 arg1 = mapform_octave;
24303 }
24304 else
24305 {
24306 arg1 = NULL;
24307 }
24308 }
24309 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24310 if (!SWIG_IsOK(res2)) {
24311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapstring" "', argument " "2"" of type '" "char const *""'");
24312 }
24313 arg2 = reinterpret_cast< char * >(buf2);
24314 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
24315 if (!SWIG_IsOK(res3)) {
24316 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plmapstring" "', argument " "3"" of type '" "char const *""'");
24317 }
24318 arg3 = reinterpret_cast< char * >(buf3);
24319 ecode4 = SWIG_AsVal_double(args(3), &val4);
24320 if (!SWIG_IsOK(ecode4)) {
24321 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapstring" "', argument " "4"" of type '" "PLFLT""'");
24322 }
24323 arg4 = static_cast< PLFLT >(val4);
24324 ecode5 = SWIG_AsVal_double(args(4), &val5);
24325 if (!SWIG_IsOK(ecode5)) {
24326 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapstring" "', argument " "5"" of type '" "PLFLT""'");
24327 }
24328 arg5 = static_cast< PLFLT >(val5);
24329 ecode6 = SWIG_AsVal_double(args(5), &val6);
24330 if (!SWIG_IsOK(ecode6)) {
24331 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapstring" "', argument " "6"" of type '" "PLFLT""'");
24332 }
24333 arg6 = static_cast< PLFLT >(val6);
24334 ecode7 = SWIG_AsVal_double(args(6), &val7);
24335 if (!SWIG_IsOK(ecode7)) {
24336 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmapstring" "', argument " "7"" of type '" "PLFLT""'");
24337 }
24338 arg7 = static_cast< PLFLT >(val7);
24339 {
24340 if ( _n_dims( args(7) ) > 1 )
24341 {
24342 error( "argument must be a scalar or vector" ); SWIG_fail;
24343 }
24344 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24345 if ( !args(7).isempty() )
24346 #else
24347 if ( !args(7).is_empty() )
24348 #endif
24349 {
24350 arg9 = (PLINT) ( _dim( args(7), 0 ) );
24351 temp8 = args(7).matrix_value();
24352 arg8 = new PLINT[arg9];
24353 _cvt_double_to( arg8, &temp8( 0, 0 ), arg9 );
24354 }
24355 else
24356 {
24357 arg8 = NULL;
24358 arg9 = 0;
24359 }
24360 }
24361 plmapstring(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,(int const *)arg8,arg9);
24362 _outv = octave_value();
24363 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24364 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24365 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
24366 {
24367 delete [] arg8;
24368 }
24369 return _out;
24370 fail:
24371 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24372 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
24373 {
24374 delete [] arg8;
24375 }
24376 return octave_value_list();
24377 }
24378
24379
24380 SWIG_DEFUN( plmaptex, _wrap_plmaptex, _wrap_plmaptex_texinfo ) {
24381 mapform_func arg1 = (mapform_func) 0 ;
24382 char *arg2 = (char *) 0 ;
24383 PLFLT arg3 ;
24384 PLFLT arg4 ;
24385 PLFLT arg5 ;
24386 char *arg6 = (char *) 0 ;
24387 PLFLT arg7 ;
24388 PLFLT arg8 ;
24389 PLFLT arg9 ;
24390 PLFLT arg10 ;
24391 PLINT arg11 ;
24392 int res2 ;
24393 char *buf2 = 0 ;
24394 int alloc2 = 0 ;
24395 double val3 ;
24396 int ecode3 = 0 ;
24397 double val4 ;
24398 int ecode4 = 0 ;
24399 double val5 ;
24400 int ecode5 = 0 ;
24401 int res6 ;
24402 char *buf6 = 0 ;
24403 int alloc6 = 0 ;
24404 double val7 ;
24405 int ecode7 = 0 ;
24406 double val8 ;
24407 int ecode8 = 0 ;
24408 double val9 ;
24409 int ecode9 = 0 ;
24410 double val10 ;
24411 int ecode10 = 0 ;
24412 int val11 ;
24413 int ecode11 = 0 ;
24414 octave_value_list _out;
24415 octave_value_list *_outp=&_out;
24416 octave_value _outv;
24417
24418 if (!SWIG_check_num_args("plmaptex",args.length(),11,11,0)) {
24419 SWIG_fail;
24420 }
24421 {
24422 octave_value obj = args(0);
24423 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24424 if ( !obj.isempty() )
24425 #else
24426 if ( !obj.is_empty() )
24427 #endif
24428 {
24429 if ( obj.is_function_handle() || obj.is_inline_function() )
24430 {
24431 fcnMapForm = obj.function_value();
24432 }
24433 else if ( obj.is_string() )
24434 {
24435 nameMapForm = obj.string_value();
24436 fcnMapForm = NULL;
24437 }
24438 arg1 = mapform_octave;
24439 }
24440 else
24441 {
24442 arg1 = NULL;
24443 }
24444 }
24445 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24446 if (!SWIG_IsOK(res2)) {
24447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmaptex" "', argument " "2"" of type '" "char const *""'");
24448 }
24449 arg2 = reinterpret_cast< char * >(buf2);
24450 ecode3 = SWIG_AsVal_double(args(2), &val3);
24451 if (!SWIG_IsOK(ecode3)) {
24452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmaptex" "', argument " "3"" of type '" "PLFLT""'");
24453 }
24454 arg3 = static_cast< PLFLT >(val3);
24455 ecode4 = SWIG_AsVal_double(args(3), &val4);
24456 if (!SWIG_IsOK(ecode4)) {
24457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmaptex" "', argument " "4"" of type '" "PLFLT""'");
24458 }
24459 arg4 = static_cast< PLFLT >(val4);
24460 ecode5 = SWIG_AsVal_double(args(4), &val5);
24461 if (!SWIG_IsOK(ecode5)) {
24462 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmaptex" "', argument " "5"" of type '" "PLFLT""'");
24463 }
24464 arg5 = static_cast< PLFLT >(val5);
24465 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
24466 if (!SWIG_IsOK(res6)) {
24467 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plmaptex" "', argument " "6"" of type '" "char const *""'");
24468 }
24469 arg6 = reinterpret_cast< char * >(buf6);
24470 ecode7 = SWIG_AsVal_double(args(6), &val7);
24471 if (!SWIG_IsOK(ecode7)) {
24472 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmaptex" "', argument " "7"" of type '" "PLFLT""'");
24473 }
24474 arg7 = static_cast< PLFLT >(val7);
24475 ecode8 = SWIG_AsVal_double(args(7), &val8);
24476 if (!SWIG_IsOK(ecode8)) {
24477 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plmaptex" "', argument " "8"" of type '" "PLFLT""'");
24478 }
24479 arg8 = static_cast< PLFLT >(val8);
24480 ecode9 = SWIG_AsVal_double(args(8), &val9);
24481 if (!SWIG_IsOK(ecode9)) {
24482 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plmaptex" "', argument " "9"" of type '" "PLFLT""'");
24483 }
24484 arg9 = static_cast< PLFLT >(val9);
24485 ecode10 = SWIG_AsVal_double(args(9), &val10);
24486 if (!SWIG_IsOK(ecode10)) {
24487 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plmaptex" "', argument " "10"" of type '" "PLFLT""'");
24488 }
24489 arg10 = static_cast< PLFLT >(val10);
24490 ecode11 = SWIG_AsVal_int(args(10), &val11);
24491 if (!SWIG_IsOK(ecode11)) {
24492 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plmaptex" "', argument " "11"" of type '" "PLINT""'");
24493 }
24494 arg11 = static_cast< PLINT >(val11);
24495 plmaptex(arg1,(char const *)arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
24496 _outv = octave_value();
24497 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24498 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24499 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
24500 return _out;
24501 fail:
24502 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24503 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
24504 return octave_value_list();
24505 }
24506
24507
24508 SWIG_DEFUN( plmapfill, _wrap_plmapfill, _wrap_plmapfill_texinfo ) {
24509 mapform_func arg1 = (mapform_func) 0 ;
24510 char *arg2 = (char *) 0 ;
24511 PLFLT arg3 ;
24512 PLFLT arg4 ;
24513 PLFLT arg5 ;
24514 PLFLT arg6 ;
24515 PLINT *arg7 = (PLINT *) 0 ;
24516 PLINT arg8 ;
24517 int res2 ;
24518 char *buf2 = 0 ;
24519 int alloc2 = 0 ;
24520 double val3 ;
24521 int ecode3 = 0 ;
24522 double val4 ;
24523 int ecode4 = 0 ;
24524 double val5 ;
24525 int ecode5 = 0 ;
24526 double val6 ;
24527 int ecode6 = 0 ;
24528 Matrix temp7 ;
24529 octave_value_list _out;
24530 octave_value_list *_outp=&_out;
24531 octave_value _outv;
24532
24533 if (!SWIG_check_num_args("plmapfill",args.length(),7,7,0)) {
24534 SWIG_fail;
24535 }
24536 {
24537 octave_value obj = args(0);
24538 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24539 if ( !obj.isempty() )
24540 #else
24541 if ( !obj.is_empty() )
24542 #endif
24543 {
24544 if ( obj.is_function_handle() || obj.is_inline_function() )
24545 {
24546 fcnMapForm = obj.function_value();
24547 }
24548 else if ( obj.is_string() )
24549 {
24550 nameMapForm = obj.string_value();
24551 fcnMapForm = NULL;
24552 }
24553 arg1 = mapform_octave;
24554 }
24555 else
24556 {
24557 arg1 = NULL;
24558 }
24559 }
24560 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24561 if (!SWIG_IsOK(res2)) {
24562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmapfill" "', argument " "2"" of type '" "char const *""'");
24563 }
24564 arg2 = reinterpret_cast< char * >(buf2);
24565 ecode3 = SWIG_AsVal_double(args(2), &val3);
24566 if (!SWIG_IsOK(ecode3)) {
24567 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmapfill" "', argument " "3"" of type '" "PLFLT""'");
24568 }
24569 arg3 = static_cast< PLFLT >(val3);
24570 ecode4 = SWIG_AsVal_double(args(3), &val4);
24571 if (!SWIG_IsOK(ecode4)) {
24572 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmapfill" "', argument " "4"" of type '" "PLFLT""'");
24573 }
24574 arg4 = static_cast< PLFLT >(val4);
24575 ecode5 = SWIG_AsVal_double(args(4), &val5);
24576 if (!SWIG_IsOK(ecode5)) {
24577 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmapfill" "', argument " "5"" of type '" "PLFLT""'");
24578 }
24579 arg5 = static_cast< PLFLT >(val5);
24580 ecode6 = SWIG_AsVal_double(args(5), &val6);
24581 if (!SWIG_IsOK(ecode6)) {
24582 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmapfill" "', argument " "6"" of type '" "PLFLT""'");
24583 }
24584 arg6 = static_cast< PLFLT >(val6);
24585 {
24586 if ( _n_dims( args(6) ) > 1 )
24587 {
24588 error( "argument must be a scalar or vector" ); SWIG_fail;
24589 }
24590 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24591 if ( !args(6).isempty() )
24592 #else
24593 if ( !args(6).is_empty() )
24594 #endif
24595 {
24596 arg8 = (PLINT) ( _dim( args(6), 0 ) );
24597 temp7 = args(6).matrix_value();
24598 arg7 = new PLINT[arg8];
24599 _cvt_double_to( arg7, &temp7( 0, 0 ), arg8 );
24600 }
24601 else
24602 {
24603 arg7 = NULL;
24604 arg8 = 0;
24605 }
24606 }
24607 plmapfill(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,(int const *)arg7,arg8);
24608 _outv = octave_value();
24609 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24610 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24611 {
24612 delete [] arg7;
24613 }
24614 return _out;
24615 fail:
24616 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24617 {
24618 delete [] arg7;
24619 }
24620 return octave_value_list();
24621 }
24622
24623
24624 SWIG_DEFUN( plmeridians, _wrap_plmeridians, _wrap_plmeridians_texinfo ) {
24625 mapform_func arg1 = (mapform_func) 0 ;
24626 PLFLT arg2 ;
24627 PLFLT arg3 ;
24628 PLFLT arg4 ;
24629 PLFLT arg5 ;
24630 PLFLT arg6 ;
24631 PLFLT arg7 ;
24632 double val2 ;
24633 int ecode2 = 0 ;
24634 double val3 ;
24635 int ecode3 = 0 ;
24636 double val4 ;
24637 int ecode4 = 0 ;
24638 double val5 ;
24639 int ecode5 = 0 ;
24640 double val6 ;
24641 int ecode6 = 0 ;
24642 double val7 ;
24643 int ecode7 = 0 ;
24644 octave_value_list _out;
24645 octave_value_list *_outp=&_out;
24646 octave_value _outv;
24647
24648 if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
24649 SWIG_fail;
24650 }
24651 {
24652 octave_value obj = args(0);
24653 #if SWIG_OCTAVE_PREREQ( 4, 4, 0 )
24654 if ( !obj.isempty() )
24655 #else
24656 if ( !obj.is_empty() )
24657 #endif
24658 {
24659 if ( obj.is_function_handle() || obj.is_inline_function() )
24660 {
24661 fcnMapForm = obj.function_value();
24662 }
24663 else if ( obj.is_string() )
24664 {
24665 nameMapForm = obj.string_value();
24666 fcnMapForm = NULL;
24667 }
24668 arg1 = mapform_octave;
24669 }
24670 else
24671 {
24672 arg1 = NULL;
24673 }
24674 }
24675 ecode2 = SWIG_AsVal_double(args(1), &val2);
24676 if (!SWIG_IsOK(ecode2)) {
24677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
24678 }
24679 arg2 = static_cast< PLFLT >(val2);
24680 ecode3 = SWIG_AsVal_double(args(2), &val3);
24681 if (!SWIG_IsOK(ecode3)) {
24682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
24683 }
24684 arg3 = static_cast< PLFLT >(val3);
24685 ecode4 = SWIG_AsVal_double(args(3), &val4);
24686 if (!SWIG_IsOK(ecode4)) {
24687 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
24688 }
24689 arg4 = static_cast< PLFLT >(val4);
24690 ecode5 = SWIG_AsVal_double(args(4), &val5);
24691 if (!SWIG_IsOK(ecode5)) {
24692 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
24693 }
24694 arg5 = static_cast< PLFLT >(val5);
24695 ecode6 = SWIG_AsVal_double(args(5), &val6);
24696 if (!SWIG_IsOK(ecode6)) {
24697 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
24698 }
24699 arg6 = static_cast< PLFLT >(val6);
24700 ecode7 = SWIG_AsVal_double(args(6), &val7);
24701 if (!SWIG_IsOK(ecode7)) {
24702 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
24703 }
24704 arg7 = static_cast< PLFLT >(val7);
24705 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24706 _outv = octave_value();
24707 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24708 return _out;
24709 fail:
24710 return octave_value_list();
24711 }
24712
24713
24714 SWIG_DEFUN( plClearOpts, _wrap_plClearOpts, std::string() ) {
24715 octave_value_list _out;
24716 octave_value_list *_outp=&_out;
24717 octave_value _outv;
24718
24719 if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
24720 SWIG_fail;
24721 }
24722 plClearOpts();
24723 _outv = octave_value();
24724 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24725 return _out;
24726 fail:
24727 return octave_value_list();
24728 }
24729
24730
24731 SWIG_DEFUN( plResetOpts, _wrap_plResetOpts, std::string() ) {
24732 octave_value_list _out;
24733 octave_value_list *_outp=&_out;
24734 octave_value _outv;
24735
24736 if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
24737 SWIG_fail;
24738 }
24739 plResetOpts();
24740 _outv = octave_value();
24741 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24742 return _out;
24743 fail:
24744 return octave_value_list();
24745 }
24746
24747
24748 SWIG_DEFUN( plSetUsage, _wrap_plSetUsage, std::string() ) {
24749 char *arg1 = (char *) 0 ;
24750 char *arg2 = (char *) 0 ;
24751 int res1 ;
24752 char *buf1 = 0 ;
24753 int alloc1 = 0 ;
24754 int res2 ;
24755 char *buf2 = 0 ;
24756 int alloc2 = 0 ;
24757 octave_value_list _out;
24758 octave_value_list *_outp=&_out;
24759 octave_value _outv;
24760
24761 if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
24762 SWIG_fail;
24763 }
24764 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
24765 if (!SWIG_IsOK(res1)) {
24766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
24767 }
24768 arg1 = reinterpret_cast< char * >(buf1);
24769 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
24770 if (!SWIG_IsOK(res2)) {
24771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
24772 }
24773 arg2 = reinterpret_cast< char * >(buf2);
24774 plSetUsage((char const *)arg1,(char const *)arg2);
24775 _outv = octave_value();
24776 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24777 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24778 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24779 return _out;
24780 fail:
24781 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
24782 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
24783 return octave_value_list();
24784 }
24785
24786
24787 SWIG_DEFUN( plOptUsage, _wrap_plOptUsage, std::string() ) {
24788 octave_value_list _out;
24789 octave_value_list *_outp=&_out;
24790 octave_value _outv;
24791
24792 if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
24793 SWIG_fail;
24794 }
24795 plOptUsage();
24796 _outv = octave_value();
24797 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
24798 return _out;
24799 fail:
24800 return octave_value_list();
24801 }
24802
24803
24804
24805 static const struct swig_octave_member swig_globals[] = {
24806 {"testppchar",_wrap_testppchar,0,0,2,0},
24807 {"plGetCursor",_wrap_plGetCursor,0,0,2,_wrap_plGetCursor_texinfo},
24808 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
24809 {"plstripc",_wrap_plstripc,0,0,2,_wrap_plstripc_texinfo},
24810 {"plcont",_wrap_plcont,0,0,2,_wrap_plcont_texinfo},
24811 {"plcont0",_wrap_plcont0,0,0,2,0},
24812 {"plcont1",_wrap_plcont1,0,0,2,0},
24813 {"plcont2",_wrap_plcont2,0,0,2,0},
24814 {"plcont2p",_wrap_plcont2p,0,0,2,0},
24815 {"plgriddata",_wrap_plgriddata,0,0,2,_wrap_plgriddata_texinfo},
24816 {"plmesh",_wrap_plmesh,0,0,2,_wrap_plmesh_texinfo},
24817 {"plmeshc",_wrap_plmeshc,0,0,2,_wrap_plmeshc_texinfo},
24818 {"plot3d",_wrap_plot3d,0,0,2,_wrap_plot3d_texinfo},
24819 {"plot3dc",_wrap_plot3dc,0,0,2,_wrap_plot3dc_texinfo},
24820 {"plot3dcl",_wrap_plot3dcl,0,0,2,_wrap_plot3dcl_texinfo},
24821 {"plsurf3d",_wrap_plsurf3d,0,0,2,_wrap_plsurf3d_texinfo},
24822 {"plsurf3dl",_wrap_plsurf3dl,0,0,2,_wrap_plsurf3dl_texinfo},
24823 {"plshade",_wrap_plshade,0,0,2,_wrap_plshade_texinfo},
24824 {"plshade1",_wrap_plshade1,0,0,2,0},
24825 {"plshade2",_wrap_plshade2,0,0,2,0},
24826 {"plshades",_wrap_plshades,0,0,2,_wrap_plshades_texinfo},
24827 {"plshadesx",_wrap_plshadesx,0,0,2,0},
24828 {"plshades1",_wrap_plshades1,0,0,2,0},
24829 {"plshades2",_wrap_plshades2,0,0,2,0},
24830 {"plvect",_wrap_plvect,0,0,2,_wrap_plvect_texinfo},
24831 {"plvect1",_wrap_plvect1,0,0,2,0},
24832 {"plvect2",_wrap_plvect2,0,0,2,0},
24833 {"pplimage",_wrap_pplimage,0,0,2,0},
24834 {"plimagefr",_wrap_plimagefr,0,0,2,_wrap_plimagefr_texinfo},
24835 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
24836 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
24837 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
24838 {"plcolorbar",_wrap_plcolorbar,0,0,2,_wrap_plcolorbar_texinfo},
24839 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
24840 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
24841 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
24842 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
24843 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
24844 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
24845 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
24846 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
24847 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
24848 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
24849 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
24850 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
24851 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
24852 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
24853 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
24854 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
24855 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
24856 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
24857 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
24858 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
24859 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
24860 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
24861 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
24862 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
24863 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
24864 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
24865 {"pl_setcontlabelformat",_wrap_pl_setcontlabelformat,0,0,2,_wrap_pl_setcontlabelformat_texinfo},
24866 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
24867 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
24868 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
24869 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
24870 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
24871 {"plbtime",_wrap_plbtime,0,0,2,_wrap_plbtime_texinfo},
24872 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
24873 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
24874 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
24875 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
24876 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
24877 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
24878 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
24879 {"plconfigtime",_wrap_plconfigtime,0,0,2,_wrap_plconfigtime_texinfo},
24880 {"plctime",_wrap_plctime,0,0,2,_wrap_plctime_texinfo},
24881 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
24882 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
24883 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
24884 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
24885 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
24886 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
24887 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
24888 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
24889 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
24890 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
24891 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
24892 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
24893 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
24894 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
24895 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
24896 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
24897 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
24898 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
24899 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
24900 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
24901 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
24902 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
24903 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
24904 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
24905 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
24906 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
24907 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
24908 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
24909 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
24910 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
24911 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
24912 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
24913 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
24914 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
24915 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
24916 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
24917 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
24918 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
24919 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
24920 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
24921 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
24922 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
24923 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
24924 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
24925 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
24926 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
24927 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
24928 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
24929 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
24930 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
24931 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
24932 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
24933 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
24934 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
24935 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
24936 {"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
24937 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
24938 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
24939 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
24940 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
24941 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
24942 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
24943 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
24944 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
24945 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
24946 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
24947 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
24948 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
24949 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
24950 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
24951 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
24952 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
24953 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
24954 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
24955 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
24956 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,_wrap_plscmap1_range_texinfo},
24957 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,_wrap_plgcmap1_range_texinfo},
24958 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
24959 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
24960 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
24961 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
24962 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
24963 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
24964 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
24965 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
24966 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
24967 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
24968 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
24969 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
24970 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
24971 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
24972 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
24973 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
24974 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
24975 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
24976 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
24977 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
24978 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
24979 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
24980 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
24981 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
24982 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
24983 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
24984 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
24985 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
24986 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
24987 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
24988 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
24989 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
24990 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
24991 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
24992 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
24993 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
24994 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
24995 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
24996 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
24997 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
24998 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
24999 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
25000 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
25001 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
25002 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
25003 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
25004 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
25005 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
25006 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
25007 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
25008 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
25009 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
25010 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
25011 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
25012 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
25013 {"plmapline",_wrap_plmapline,0,0,2,_wrap_plmapline_texinfo},
25014 {"plmapstring",_wrap_plmapstring,0,0,2,_wrap_plmapstring_texinfo},
25015 {"plmaptex",_wrap_plmaptex,0,0,2,_wrap_plmaptex_texinfo},
25016 {"plmapfill",_wrap_plmapfill,0,0,2,_wrap_plmapfill_texinfo},
25017 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
25018 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
25019 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
25020 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
25021 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
25022 {0,0,0,0,0,0}
25023 };
25024
25025 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
25026
25027 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
25028 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
25029 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
25030 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};
25031 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};
25032 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};
25033 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
25034 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
25035 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
25036
25037 static swig_type_info *swig_type_initial[] = {
25038 &_swigt__p_PLGraphicsIn,
25039 &_swigt__p_char,
25040 &_swigt__p_double,
25041 &_swigt__p_f_double_double_p_double_p_double_p_void__void,
25042 &_swigt__p_f_int_double_p_char_int_p_void__void,
25043 &_swigt__p_f_int_p_double_p_double__void,
25044 &_swigt__p_int,
25045 &_swigt__p_p_char,
25046 &_swigt__p_unsigned_int,
25047 };
25048
25049 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
25050 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
25051 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
25052 static swig_cast_info _swigc__p_f_double_double_p_double_p_double_p_void__void[] = { {&_swigt__p_f_double_double_p_double_p_double_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
25053 static swig_cast_info _swigc__p_f_int_double_p_char_int_p_void__void[] = { {&_swigt__p_f_int_double_p_char_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
25054 static swig_cast_info _swigc__p_f_int_p_double_p_double__void[] = { {&_swigt__p_f_int_p_double_p_double__void, 0, 0, 0},{0, 0, 0, 0}};
25055 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
25056 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
25057 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
25058
25059 static swig_cast_info *swig_cast_initial[] = {
25060 _swigc__p_PLGraphicsIn,
25061 _swigc__p_char,
25062 _swigc__p_double,
25063 _swigc__p_f_double_double_p_double_p_double_p_void__void,
25064 _swigc__p_f_int_double_p_char_int_p_void__void,
25065 _swigc__p_f_int_p_double_p_double__void,
25066 _swigc__p_int,
25067 _swigc__p_p_char,
25068 _swigc__p_unsigned_int,
25069 };
25070
25071
25072 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
25073
25074 /* -----------------------------------------------------------------------------
25075 * Type initialization:
25076 * This problem is tough by the requirement that no dynamic
25077 * memory is used. Also, since swig_type_info structures store pointers to
25078 * swig_cast_info structures and swig_cast_info structures store pointers back
25079 * to swig_type_info structures, we need some lookup code at initialization.
25080 * The idea is that swig generates all the structures that are needed.
25081 * The runtime then collects these partially filled structures.
25082 * The SWIG_InitializeModule function takes these initial arrays out of
25083 * swig_module, and does all the lookup, filling in the swig_module.types
25084 * array with the correct data and linking the correct swig_cast_info
25085 * structures together.
25086 *
25087 * The generated swig_type_info structures are assigned statically to an initial
25088 * array. We just loop through that array, and handle each type individually.
25089 * First we lookup if this type has been already loaded, and if so, use the
25090 * loaded structure instead of the generated one. Then we have to fill in the
25091 * cast linked list. The cast data is initially stored in something like a
25092 * two-dimensional array. Each row corresponds to a type (there are the same
25093 * number of rows as there are in the swig_type_initial array). Each entry in
25094 * a column is one of the swig_cast_info structures for that type.
25095 * The cast_initial array is actually an array of arrays, because each row has
25096 * a variable number of columns. So to actually build the cast linked list,
25097 * we find the array of casts associated with the type, and loop through it
25098 * adding the casts to the list. The one last trick we need to do is making
25099 * sure the type pointer in the swig_cast_info struct is correct.
25100 *
25101 * First off, we lookup the cast->type name to see if it is already loaded.
25102 * There are three cases to handle:
25103 * 1) If the cast->type has already been loaded AND the type we are adding
25104 * casting info to has not been loaded (it is in this module), THEN we
25105 * replace the cast->type pointer with the type pointer that has already
25106 * been loaded.
25107 * 2) If BOTH types (the one we are adding casting info to, and the
25108 * cast->type) are loaded, THEN the cast info has already been loaded by
25109 * the previous module so we just ignore it.
25110 * 3) Finally, if cast->type has not already been loaded, then we add that
25111 * swig_cast_info to the linked list (because the cast->type) pointer will
25112 * be correct.
25113 * ----------------------------------------------------------------------------- */
25114
25115 #ifdef __cplusplus
25116 extern "C" {
25117 #if 0
25118 } /* c-mode */
25119 #endif
25120 #endif
25121
25122 #if 0
25123 #define SWIGRUNTIME_DEBUG
25124 #endif
25125
25126
25127 SWIGRUNTIME void
25128 SWIG_InitializeModule(void *clientdata) {
25129 size_t i;
25130 swig_module_info *module_head, *iter;
25131 int init;
25132
25133 /* check to see if the circular list has been setup, if not, set it up */
25134 if (swig_module.next==0) {
25135 /* Initialize the swig_module */
25136 swig_module.type_initial = swig_type_initial;
25137 swig_module.cast_initial = swig_cast_initial;
25138 swig_module.next = &swig_module;
25139 init = 1;
25140 } else {
25141 init = 0;
25142 }
25143
25144 /* Try and load any already created modules */
25145 module_head = SWIG_GetModule(clientdata);
25146 if (!module_head) {
25147 /* This is the first module loaded for this interpreter */
25148 /* so set the swig module into the interpreter */
25149 SWIG_SetModule(clientdata, &swig_module);
25150 } else {
25151 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
25152 iter=module_head;
25153 do {
25154 if (iter==&swig_module) {
25155 /* Our module is already in the list, so there's nothing more to do. */
25156 return;
25157 }
25158 iter=iter->next;
25159 } while (iter!= module_head);
25160
25161 /* otherwise we must add our module into the list */
25162 swig_module.next = module_head->next;
25163 module_head->next = &swig_module;
25164 }
25165
25166 /* When multiple interpreters are used, a module could have already been initialized in
25167 a different interpreter, but not yet have a pointer in this interpreter.
25168 In this case, we do not want to continue adding types... everything should be
25169 set up already */
25170 if (init == 0) return;
25171
25172 /* Now work on filling in swig_module.types */
25173 #ifdef SWIGRUNTIME_DEBUG
25174 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
25175 #endif
25176 for (i = 0; i < swig_module.size; ++i) {
25177 swig_type_info *type = 0;
25178 swig_type_info *ret;
25179 swig_cast_info *cast;
25180
25181 #ifdef SWIGRUNTIME_DEBUG
25182 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
25183 #endif
25184
25185 /* if there is another module already loaded */
25186 if (swig_module.next != &swig_module) {
25187 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
25188 }
25189 if (type) {
25190 /* Overwrite clientdata field */
25191 #ifdef SWIGRUNTIME_DEBUG
25192 printf("SWIG_InitializeModule: found type %s\n", type->name);
25193 #endif
25194 if (swig_module.type_initial[i]->clientdata) {
25195 type->clientdata = swig_module.type_initial[i]->clientdata;
25196 #ifdef SWIGRUNTIME_DEBUG
25197 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
25198 #endif
25199 }
25200 } else {
25201 type = swig_module.type_initial[i];
25202 }
25203
25204 /* Insert casting types */
25205 cast = swig_module.cast_initial[i];
25206 while (cast->type) {
25207
25208 /* Don't need to add information already in the list */
25209 ret = 0;
25210 #ifdef SWIGRUNTIME_DEBUG
25211 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
25212 #endif
25213 if (swig_module.next != &swig_module) {
25214 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
25215 #ifdef SWIGRUNTIME_DEBUG
25216 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
25217 #endif
25218 }
25219 if (ret) {
25220 if (type == swig_module.type_initial[i]) {
25221 #ifdef SWIGRUNTIME_DEBUG
25222 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
25223 #endif
25224 cast->type = ret;
25225 ret = 0;
25226 } else {
25227 /* Check for casting already in the list */
25228 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
25229 #ifdef SWIGRUNTIME_DEBUG
25230 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
25231 #endif
25232 if (!ocast) ret = 0;
25233 }
25234 }
25235
25236 if (!ret) {
25237 #ifdef SWIGRUNTIME_DEBUG
25238 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
25239 #endif
25240 if (type->cast) {
25241 type->cast->prev = cast;
25242 cast->next = type->cast;
25243 }
25244 type->cast = cast;
25245 }
25246 cast++;
25247 }
25248 /* Set entry in modules->types array equal to the type */
25249 swig_module.types[i] = type;
25250 }
25251 swig_module.types[i] = 0;
25252
25253 #ifdef SWIGRUNTIME_DEBUG
25254 printf("**** SWIG_InitializeModule: Cast List ******\n");
25255 for (i = 0; i < swig_module.size; ++i) {
25256 int j = 0;
25257 swig_cast_info *cast = swig_module.cast_initial[i];
25258 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
25259 while (cast->type) {
25260 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
25261 cast++;
25262 ++j;
25263 }
25264 printf("---- Total casts: %d\n",j);
25265 }
25266 printf("**** SWIG_InitializeModule: Cast List ******\n");
25267 #endif
25268 }
25269
25270 /* This function will propagate the clientdata field of type to
25271 * any new swig_type_info structures that have been added into the list
25272 * of equivalent types. It is like calling
25273 * SWIG_TypeClientData(type, clientdata) a second time.
25274 */
25275 SWIGRUNTIME void
25276 SWIG_PropagateClientData(void) {
25277 size_t i;
25278 swig_cast_info *equiv;
25279 static int init_run = 0;
25280
25281 if (init_run) return;
25282 init_run = 1;
25283
25284 for (i = 0; i < swig_module.size; i++) {
25285 if (swig_module.types[i]->clientdata) {
25286 equiv = swig_module.types[i]->cast;
25287 while (equiv) {
25288 if (!equiv->converter) {
25289 if (equiv->type && !equiv->type->clientdata)
25290 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
25291 }
25292 equiv = equiv->next;
25293 }
25294 }
25295 }
25296 }
25297
25298 #ifdef __cplusplus
25299 #if 0
25300 { /* c-mode */
25301 #endif
25302 }
25303 #endif
25304
25305
25306
25307 static bool SWIG_init_user(octave_swig_type* module_ns);
25308
25309 SWIGINTERN bool SWIG_Octave_LoadModule(std::string name) {
25310 bool retn = false;
25311 {
25312 #if SWIG_OCTAVE_PREREQ(4,2,0)
25313 octave::unwind_protect frame;
25314 frame.protect_var(discard_error_messages); discard_error_messages = true;
25315 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25316 #elif SWIG_OCTAVE_PREREQ(3,3,50)
25317 unwind_protect frame;
25318 frame.protect_var(error_state); error_state = 0;
25319 frame.protect_var(warning_state); warning_state = 0;
25320 frame.protect_var(discard_error_messages); discard_error_messages = true;
25321 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25322 #else
25323 unwind_protect::begin_frame("SWIG_Octave_LoadModule");
25324 unwind_protect_int(error_state); error_state = 0;
25325 unwind_protect_int(warning_state); warning_state = 0;
25326 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
25327 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
25328 #endif
25329 #if SWIG_OCTAVE_PREREQ(4,2,0)
25330 try {
25331 #if SWIG_OCTAVE_PREREQ(4,4,0)
25332 octave::feval(name, octave_value_list(), 0);
25333 #else
25334 feval(name, octave_value_list(), 0);
25335 #endif
25336 retn = true;
25337 } catch (octave::execution_exception&) { }
25338 #else
25339 feval(name, octave_value_list(), 0);
25340 retn = (error_state == 0);
25341 #endif
25342 #if !SWIG_OCTAVE_PREREQ(3,3,50)
25343 unwind_protect::run_frame("SWIG_Octave_LoadModule");
25344 #endif
25345 }
25346 if (!retn) {
25347 error(SWIG_name_d ": could not load module `%s'", name.c_str());
25348 }
25349 return retn;
25350 }
25351
25352 SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
25353 bool retn = false;
25354 {
25355 #if SWIG_OCTAVE_PREREQ(4,2,0)
25356 octave::unwind_protect frame;
25357 frame.protect_var(discard_error_messages); discard_error_messages = true;
25358 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25359 #elif SWIG_OCTAVE_PREREQ(3,3,50)
25360 unwind_protect frame;
25361 frame.protect_var(error_state); error_state = 0;
25362 frame.protect_var(warning_state); warning_state = 0;
25363 frame.protect_var(discard_error_messages); discard_error_messages = true;
25364 frame.protect_var(discard_warning_messages); discard_warning_messages = true;
25365 #else
25366 unwind_protect::begin_frame("SWIG_Octave_InstallFunction");
25367 unwind_protect_int(error_state); error_state = 0;
25368 unwind_protect_int(warning_state); warning_state = 0;
25369 unwind_protect_bool(discard_error_messages); discard_error_messages = true;
25370 unwind_protect_bool(discard_warning_messages); discard_warning_messages = true;
25371 #endif
25372 octave_value_list args;
25373 args.append(name);
25374 args.append(octloadfcn->fcn_file_name());
25375 #if SWIG_OCTAVE_PREREQ(4,2,0)
25376 try {
25377 #if SWIG_OCTAVE_PREREQ(4,4,0)
25378 octave::feval("autoload", args, 0);
25379 #else
25380 feval("autoload", args, 0);
25381 #endif
25382 retn = true;
25383 } catch (octave::execution_exception&) { }
25384 #else
25385 feval("autoload", args, 0);
25386 retn = (error_state == 0);
25387 #endif
25388 #if !SWIG_OCTAVE_PREREQ(3,3,50)
25389 unwind_protect::run_frame("SWIG_Octave_InstallFunction");
25390 #endif
25391 }
25392 if (!retn) {
25393 error(SWIG_name_d ": could not load function `%s'", name.c_str());
25394 }
25395 return retn;
25396 }
25397
25398 static const char *const subclass_usage = "-*- texinfo -*- \n\
25399 @deftypefn {Loadable Function} {} subclass()\n\
25400 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
25401 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
25402 \n\
25403 See the SWIG manual for usage examples.\n\
25404 @end deftypefn";
25405
25406 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
25407 octave_swig_type *top = new octave_swig_type;
25408 for (int j = 0; j < args.length(); ++j) {
25409 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
25410 octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
25411 octave_swig_type *ost = osr->get_ptr();
25412 if (!ost->is_owned()) {
25413 error("subclass: cannot subclass object not constructed on octave side");
25414 return octave_value_list();
25415 }
25416 top->merge(*ost);
25417 } else if (args(j).is_function_handle()) {
25418 top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
25419 } else if (args(j).is_string()) {
25420 if (j + 1 >= args.length()) {
25421 error("subclass: member assignments must be of string,value form");
25422 return octave_value_list();
25423 }
25424 top->assign(args(j).string_value(), args(j + 1));
25425 ++j;
25426 } else {
25427 error("subclass: invalid arguments to subclass()");
25428 return octave_value_list();
25429 }
25430 }
25431 return octave_value(Swig::swig_value_ref(top));
25432 }
25433
25434 static const char *const swig_type_usage = "-*- texinfo -*- \n\
25435 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
25436 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
25437 @end deftypefn";
25438
25439 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
25440 if (args.length() != 1) {
25441 error("swig_type: must be called with only a single object");
25442 return octave_value_list();
25443 }
25444 octave_swig_type *ost = Swig::swig_value_deref(args(0));
25445 if (!ost) {
25446 error("swig_type: object is not a swig_ref");
25447 return octave_value_list();
25448 }
25449 return octave_value(ost->swig_type_name());
25450 }
25451
25452 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
25453 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
25454 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
25455 otherwise return `<unknown>'.\n\
25456 @end deftypefn";
25457
25458 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
25459 if (args.length() != 1 || !args(0).is_string()) {
25460 error("swig_typequery: must be called with single string argument");
25461 return octave_value_list();
25462 }
25463 swig_module_info *module = SWIG_GetModule(0);
25464 swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
25465 if (!type)
25466 return octave_value("<unknown>");
25467 return octave_value(type->name);
25468 }
25469
25470 static const char *const swig_this_usage = "-*- texinfo -*- \n\
25471 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
25472 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
25473 @end deftypefn";
25474
25475 DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
25476 if (args.length() != 1) {
25477 error("swig_this: must be called with only a single object");
25478 return octave_value_list();
25479 }
25480 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
25481 return octave_value(octave_uint64(0));
25482 octave_swig_type *ost = Swig::swig_value_deref(args(0));
25483 if (!ost) {
25484 error("swig_this: object is not a swig_ref");
25485 return octave_value_list();
25486 }
25487 return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
25488 }
25489
25490 static const char *const swig_octave_prereq_usage = "-*- texinfo -*- \n\
25491 @deftypefn {Loadable Function} {} swig_octave_prereq(@var{major}, @var{minor}, @var{patch})\n\
25492 Return true if the version of Octave is at least @var{major}.@var{minor}.@var{patch}.\n\
25493 @end deftypefn";
25494
25495 DEFUN_DLD( swig_octave_prereq, args, nargout, swig_octave_prereq_usage ) {
25496 if (args.length() != 3) {
25497 error("swig_octave_prereq: must be called with 3 arguments");
25498 return octave_value_list();
25499 }
25500 const int major = args(0).int_value();
25501 const int minor = args(1).int_value();
25502 const int patch = args(2).int_value();
25503 const bool prereq = SWIG_OCTAVE_PREREQ(major, minor, patch);
25504 return octave_value(prereq);
25505 }
25506
25507 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
25508 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
25509 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
25510 @end deftypefn";
25511
25512 void __swig_atexit__(void) { ::_Exit(0); }
25513
25514 DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
25515
25516 static octave_swig_type* module_ns = 0;
25517
25518 // workaround to prevent octave seg-faulting on exit: set Octave exit function
25519 // octave_exit to _Exit, which exits immediately without trying to cleanup memory.
25520 // definitely affected version 3.2.*, not sure about 3.3.*, seems to be fixed in
25521 // version 3.4.*, but reappeared in 4.2.*, so turn on for all versions after 3.2.*.
25522 // can be turned off with macro definition.
25523 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
25524 #if SWIG_OCTAVE_PREREQ(4,4,0)
25525 atexit(__swig_atexit__);
25526 #elif SWIG_OCTAVE_PREREQ(3,2,0)
25527 octave_exit = ::_Exit;
25528 #endif
25529 #endif
25530
25531 // check for no input and output args
25532 if (args.length() != 0 || nargout != 0) {
25533 print_usage();
25534 return octave_value_list();
25535 }
25536
25537 // create module on first function call
25538 if (!module_ns) {
25539
25540 // workaround bug in octave where installing global variable of custom type and then
25541 // exiting without explicitly clearing the variable causes octave to segfault.
25542 #if SWIG_OCTAVE_PREREQ(3,2,0)
25543 octave_value_list eval_args;
25544 eval_args.append("base");
25545 eval_args.append("function __swig_atexit__; "
25546 " if mislocked() "
25547 " clear -all; "
25548 " else "
25549 " mlock(); "
25550 " endif; "
25551 "endfunction; "
25552 "__swig_atexit__; "
25553 "atexit(\"__swig_atexit__\", false); "
25554 "atexit(\"__swig_atexit__\")");
25555 #if SWIG_OCTAVE_PREREQ(4,4,0)
25556 octave::feval("evalin", eval_args, 0);
25557 #else
25558 feval("evalin", eval_args, 0);
25559 #endif
25560 #endif
25561
25562 #if SWIG_OCTAVE_PREREQ(4,4,0)
25563 {
25564 octave::type_info& typeinfo = octave::interpreter::the_interpreter()->get_type_info();
25565 string_vector types = typeinfo.installed_type_names();
25566 bool register_octave_swig_ref = true;
25567 bool register_octave_swig_packed = true;
25568 bool register_octave_swig_bound_func = true;
25569 for (int i = 0; i < types.numel(); ++i) {
25570 if (types(i) == octave_swig_ref::static_type_name()) {
25571 register_octave_swig_ref = false;
25572 }
25573 if (types(i) == octave_swig_packed::static_type_name()) {
25574 register_octave_swig_packed = false;
25575 }
25576 if (types(i) == octave_swig_bound_func::static_type_name()) {
25577 register_octave_swig_bound_func = false;
25578 }
25579 }
25580 if (register_octave_swig_ref) {
25581 octave_swig_ref::register_type();
25582 }
25583 if (register_octave_swig_packed) {
25584 octave_swig_packed::register_type();
25585 }
25586 if (register_octave_swig_bound_func) {
25587 octave_swig_bound_func::register_type();
25588 }
25589 }
25590 #else
25591 octave_swig_ref::register_type();
25592 octave_swig_packed::register_type();
25593 #endif
25594 SWIG_InitializeModule(0);
25595 SWIG_PropagateClientData();
25596
25597 #if SWIG_OCTAVE_PREREQ(4,4,0)
25598 octave::call_stack& stack = octave::interpreter::the_interpreter()->get_call_stack();
25599 octave_function *me = stack.current();
25600 #else
25601 octave_function *me = octave_call_stack::current();
25602 #endif
25603
25604 if (!SWIG_Octave_InstallFunction(me, "subclass")) {
25605 return octave_value_list();
25606 }
25607 if (!SWIG_Octave_InstallFunction(me, "swig_type")) {
25608 return octave_value_list();
25609 }
25610 if (!SWIG_Octave_InstallFunction(me, "swig_typequery")) {
25611 return octave_value_list();
25612 }
25613 if (!SWIG_Octave_InstallFunction(me, "swig_this")) {
25614 return octave_value_list();
25615 }
25616 if (!SWIG_Octave_InstallFunction(me, "swig_octave_prereq")) {
25617 return octave_value_list();
25618 }
25619
25620 octave_swig_type* cvar_ns=0;
25621 if (std::string(SWIG_global_name) != ".") {
25622 cvar_ns=new octave_swig_type;
25623 for (int j=0;swig_globals[j].name;++j)
25624 if (swig_globals[j].get_method)
25625 cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
25626 }
25627
25628 module_ns=new octave_swig_type(0, 0, 0, true);
25629 if (std::string(SWIG_global_name) != ".") {
25630 module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
25631 }
25632 else {
25633 for (int j=0;swig_globals[j].name;++j)
25634 if (swig_globals[j].get_method)
25635 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
25636 }
25637 for (int j=0;swig_globals[j].name;++j)
25638 if (swig_globals[j].method)
25639 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
25640
25641 // * need better solution here; swig_type -> octave_class mapping is
25642 // * really n-to-1, in some cases such as template partial spec, etc.
25643 // * see failing tests.
25644 for (int j=0;swig_types[j];++j)
25645 if (swig_types[j]->clientdata) {
25646 swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
25647 module_ns->assign(c->name,
25648 Swig::swig_value_ref
25649 (new octave_swig_type(0,swig_types[j])));
25650 }
25651
25652 if (!SWIG_init_user(module_ns)) {
25653 delete module_ns;
25654 module_ns=0;
25655 return octave_value_list();
25656 }
25657
25658 SWIG_InstallOps(octave_swig_ref::static_type_id());
25659
25660 octave_swig_type::swig_member_const_iterator mb;
25661 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
25662 if (mb->second.first && mb->second.first->method) {
25663 if (!SWIG_Octave_InstallFunction(me, mb->first)) {
25664 return octave_value_list();
25665 }
25666 }
25667 }
25668
25669 #if SWIG_OCTAVE_PREREQ(4,4,0)
25670 octave::interpreter::the_interpreter()->mlock();
25671 #elif SWIG_OCTAVE_PREREQ(3,2,0)
25672 mlock();
25673 #else
25674 mlock(me->name());
25675 #endif
25676
25677 }
25678
25679 octave_swig_type::swig_member_const_iterator mb;
25680 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
25681 if (mb->second.second.is_defined()) {
25682 SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
25683 SWIG_Octave_LinkGlobalValue(mb->first);
25684 }
25685 }
25686
25687 SWIG_Octave_SetGlobalValue(SWIG_name_d, module_ns->as_value());
25688 SWIG_Octave_LinkGlobalValue(SWIG_name_d);
25689
25690 return octave_value_list();
25691
25692 }
25693
25694
25695 static bool SWIG_init_user(octave_swig_type* module_ns)
25696 {
25697 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int(static_cast< int >(1)));
25698 SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int(static_cast< int >(2)));
25699 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int(static_cast< int >(3)));
25700 SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int(static_cast< int >(4)));
25701 SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int(static_cast< int >(5)));
25702 SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int(static_cast< int >(6)));
25703 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int(static_cast< int >(7)));
25704 SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int(static_cast< int >(8)));
25705 SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int(static_cast< int >(9)));
25706 SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int(static_cast< int >(10)));
25707 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int(static_cast< int >(11)));
25708 SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int(static_cast< int >(12)));
25709 SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int(static_cast< int >(13)));
25710 SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int(static_cast< int >(14)));
25711 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int(static_cast< int >(15)));
25712 SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int(static_cast< int >(16)));
25713 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int(static_cast< int >(17)));
25714 SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int(static_cast< int >(18)));
25715 SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int(static_cast< int >(19)));
25716 SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int(static_cast< int >(20)));
25717 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int(static_cast< int >(21)));
25718 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int(static_cast< int >(22)));
25719 SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int(static_cast< int >(23)));
25720 SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int(static_cast< int >(24)));
25721 SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int(static_cast< int >(25)));
25722 SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int(static_cast< int >(26)));
25723 SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int(static_cast< int >(27)));
25724 SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int(static_cast< int >(28)));
25725 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int(static_cast< int >(29)));
25726 SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int(static_cast< int >(30)));
25727 SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int(static_cast< int >(31)));
25728 SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int(static_cast< int >(32)));
25729 SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int(static_cast< int >(33)));
25730 SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int(static_cast< int >(34)));
25731 SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int(static_cast< int >(35)));
25732 SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int(static_cast< int >(36)));
25733 SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int(static_cast< int >(37)));
25734 SWIG_Octave_SetConstant(module_ns,"PLESC_FIXASPECT",SWIG_From_int(static_cast< int >(38)));
25735 SWIG_Octave_SetConstant(module_ns,"PLESC_IMPORT_BUFFER",SWIG_From_int(static_cast< int >(39)));
25736 SWIG_Octave_SetConstant(module_ns,"PLESC_APPEND_BUFFER",SWIG_From_int(static_cast< int >(40)));
25737 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH_REMAINING_BUFFER",SWIG_From_int(static_cast< int >(41)));
25738 SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int(static_cast< int >(0)));
25739 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int(static_cast< int >(1)));
25740 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int(static_cast< int >(2)));
25741 SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int(static_cast< int >(3)));
25742 SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int(static_cast< int >(4)));
25743 SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int(static_cast< int >(5)));
25744 SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int(static_cast< int >(1)));
25745 SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int(static_cast< int >(2)));
25746 SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int(static_cast< int >(3)));
25747 SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int(static_cast< int >(4)));
25748 SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int(static_cast< int >(1)));
25749 SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int(static_cast< int >(2)));
25750 SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int(static_cast< int >(1)));
25751 SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int(static_cast< int >(2)));
25752 SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int(static_cast< int >(3)));
25753 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int(static_cast< int >(0x0001)));
25754 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int(static_cast< int >(0x0002)));
25755 SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
25756 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int(static_cast< int >(0x0008)));
25757 SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int(static_cast< int >(0x0010)));
25758 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int(static_cast< int >(0x0100)));
25759 SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int(static_cast< int >(0x0200)));
25760 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int(static_cast< int >(0x0400)));
25761 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int(static_cast< int >(0x0800)));
25762 SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int(static_cast< int >(0x1000)));
25763 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int(static_cast< int >(0x0000)));
25764 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int(static_cast< int >(0x0001)));
25765 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int(static_cast< int >(0x0002)));
25766 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int(static_cast< int >(0x0004)));
25767 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int(static_cast< int >(0x0008)));
25768 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int(static_cast< int >(0x0010)));
25769 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int(static_cast< int >(0x0020)));
25770 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int(static_cast< int >(0x0040)));
25771 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int(static_cast< int >(0x0080)));
25772 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int(static_cast< int >(0x80000000)));
25773 SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0x00000000)));
25774 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int(static_cast< int >(0xf)));
25775 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int(static_cast< int >(0x7)));
25776 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int(static_cast< int >(0xf)));
25777 SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int(static_cast< int >(0x0)));
25778 SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int(static_cast< int >(0x1)));
25779 SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int(static_cast< int >(0x2)));
25780 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int(static_cast< int >(0x0)));
25781 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int(static_cast< int >(0x1)));
25782 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int(static_cast< int >(0x2)));
25783 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int(static_cast< int >(0x3)));
25784 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int(static_cast< int >(0x4)));
25785 SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int(static_cast< int >(0x0)));
25786 SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int(static_cast< int >(0x1)));
25787 SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int(static_cast< int >(0x2)));
25788 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int(static_cast< int >(0x0)));
25789 SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int(static_cast< int >(0x1)));
25790 SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int(static_cast< int >(16)));
25791 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SHIFT",SWIG_From_int(static_cast< int >(0x1)));
25792 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CAPS",SWIG_From_int(static_cast< int >(0x2)));
25793 SWIG_Octave_SetConstant(module_ns,"PL_MASK_CONTROL",SWIG_From_int(static_cast< int >(0x4)));
25794 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALT",SWIG_From_int(static_cast< int >(0x8)));
25795 SWIG_Octave_SetConstant(module_ns,"PL_MASK_NUM",SWIG_From_int(static_cast< int >(0x10)));
25796 SWIG_Octave_SetConstant(module_ns,"PL_MASK_ALTGR",SWIG_From_int(static_cast< int >(0x20)));
25797 SWIG_Octave_SetConstant(module_ns,"PL_MASK_WIN",SWIG_From_int(static_cast< int >(0x40)));
25798 SWIG_Octave_SetConstant(module_ns,"PL_MASK_SCROLL",SWIG_From_int(static_cast< int >(0x80)));
25799 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON1",SWIG_From_int(static_cast< int >(0x100)));
25800 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON2",SWIG_From_int(static_cast< int >(0x200)));
25801 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON3",SWIG_From_int(static_cast< int >(0x400)));
25802 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON4",SWIG_From_int(static_cast< int >(0x800)));
25803 SWIG_Octave_SetConstant(module_ns,"PL_MASK_BUTTON5",SWIG_From_int(static_cast< int >(0x1000)));
25804 SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int(static_cast< int >(64)));
25805 SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int(static_cast< int >((-42))));
25806 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL0",SWIG_From_int(static_cast< int >(16)));
25807 SWIG_Octave_SetConstant(module_ns,"PL_DEFAULT_NCOL1",SWIG_From_int(static_cast< int >(128)));
25808 SWIG_Octave_SetConstant(module_ns,"MIN_PLINT_RGB",SWIG_From_int(static_cast< int >(0)));
25809 SWIG_Octave_SetConstant(module_ns,"MAX_PLINT_RGB",SWIG_From_int(static_cast< int >(255)));
25810 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(0.)));
25811 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_CMAP1",SWIG_From_double(static_cast< double >(1.)));
25812 SWIG_Octave_SetConstant(module_ns,"MIN_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(0.)));
25813 SWIG_Octave_SetConstant(module_ns,"MAX_PLFLT_ALPHA",SWIG_From_double(static_cast< double >(1.)));
25814 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int(static_cast< int >(1)));
25815 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int(static_cast< int >(2)));
25816 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int(static_cast< int >(3)));
25817 SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int(static_cast< int >(0x0)));
25818 SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int(static_cast< int >(0x1)));
25819 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int(static_cast< int >(0x2)));
25820 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int(static_cast< int >(0x4)));
25821 SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int(static_cast< int >(1)));
25822 SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int(static_cast< int >(2)));
25823 SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int(static_cast< int >(3)));
25824 SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int(static_cast< int >(4)));
25825 SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int(static_cast< int >(5)));
25826 SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int(static_cast< int >(6)));
25827 SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int(static_cast< int >(0x00)));
25828 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int(static_cast< int >(0x01)));
25829 SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int(static_cast< int >(0x02)));
25830 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int(static_cast< int >(0x08)));
25831 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int(static_cast< int >(0x10)));
25832 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_NULL",SWIG_From_int(static_cast< int >(0x0)));
25833 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int(static_cast< int >(0x1)));
25834 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
25835 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int(static_cast< int >(0x4)));
25836 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
25837 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int(static_cast< int >(0x10)));
25838 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int(static_cast< int >(0x20)));
25839 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int(static_cast< int >(0x40)));
25840 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int(static_cast< int >(0x80)));
25841 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NULL",SWIG_From_int(static_cast< int >(0x0)));
25842 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int(static_cast< int >(0x1)));
25843 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int(static_cast< int >(0x2)));
25844 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int(static_cast< int >(0x4)));
25845 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int(static_cast< int >(0x8)));
25846 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int(static_cast< int >(0x10)));
25847 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int(static_cast< int >(0x20)));
25848 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x40)));
25849 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int(static_cast< int >(0x80)));
25850 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_NULL",SWIG_From_int(static_cast< int >(0x0)));
25851 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int(static_cast< int >(0x1)));
25852 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int(static_cast< int >(0x2)));
25853 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int(static_cast< int >(0x4)));
25854 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int(static_cast< int >(0x8)));
25855 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int(static_cast< int >(0x10)));
25856 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int(static_cast< int >(0x20)));
25857 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int(static_cast< int >(0x40)));
25858 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int(static_cast< int >(0x80)));
25859 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int(static_cast< int >(0x100)));
25860 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int(static_cast< int >(0x200)));
25861 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int(static_cast< int >(0x400)));
25862 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int(static_cast< int >(0x800)));
25863 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int(static_cast< int >(0x1000)));
25864 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int(static_cast< int >(0x2000)));
25865 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int(static_cast< int >(0x4000)));
25866 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int(static_cast< int >(0x8000)));
25867 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int(static_cast< int >(0x10000)));
25868 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int(static_cast< int >(0x0)));
25869 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int(static_cast< int >(0x1)));
25870 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int(static_cast< int >(0x2)));
25871 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int(static_cast< int >(0x4)));
25872 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int(static_cast< int >(0x001)));
25873 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int(static_cast< int >(0x002)));
25874 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int(static_cast< int >(0x003)));
25875 SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int(static_cast< int >(0x004)));
25876 SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int(static_cast< int >(0x008)));
25877 SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int(static_cast< int >(0x010)));
25878 SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int(static_cast< int >(0x020)));
25879 SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int(static_cast< int >(0x040)));
25880 SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int(static_cast< int >(0x080)));
25881 SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int(static_cast< int >(0x100)));
25882 return true;
25883 }
25884
_wrap_pljoin_texinfo
static const char * _wrap_pljoin_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6152
_wrap_plrandd
SWIGINTERN PyObject * _wrap_plrandd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10477
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_plscolbg
SWIGINTERN PyObject * _wrap_plscolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11386
SWIG_IsOK
#define SWIG_IsOK(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:409
swig_PLGraphicsIn_base
static const swig_type_info * swig_PLGraphicsIn_base[]
Definition: plplot_octaveOCTAVE_wrap.cxx:16251
_swigc__p_int
static swig_cast_info _swigc__p_int[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25055
nameMapForm
std::string nameMapForm
Definition: plplot_octaveOCTAVE_wrap.cxx:2615
_wrap_pladv_texinfo
static const char * _wrap_pladv_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7779
plplotP.h
_wrap_plflush
SWIGINTERN PyObject * _wrap_plflush(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6568
plsfam
#define plsfam
Definition: plplot.h:816
octave_swig_ref::clone
octave_base_value * clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1944
_wrap_plmapfill
SWIGINTERN PyObject * _wrap_plmapfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14688
plplotc.plClearOpts
def plClearOpts
Definition: plplotc.py:8448
octave_swig_packed::clone
octave_base_value * clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:2088
plw3d
#define plw3d
Definition: plplot.h:862
octave_swig_type::merge
void merge(octave_swig_type &rhs)
Definition: plplot_octaveOCTAVE_wrap.cxx:1407
swigreg_binary_op
#define swigreg_binary_op(name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2235
octave_swig_type::load_members
void load_members(member_map &out) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1194
SWIG_Octave_NewPackedObj
SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type)
Definition: plplot_octaveOCTAVE_wrap.cxx:2356
_wrap_plcol0_texinfo
static const char * _wrap_plcol0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6038
_wrap_plimagefr_texinfo
static const char * _wrap_plimagefr_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9930
_wrap_plbox
SWIGINTERN PyObject * _wrap_plbox(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5392
SWIG_CheckState
#define SWIG_CheckState(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:449
_wrap_plconfigtime
SWIGINTERN PyObject * _wrap_plconfigtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5716
swig_binary_op
#define swig_binary_op(name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2217
octave_swig_type::is_map
virtual bool is_map() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1509
octave_swig_ref::empty_clone
octave_base_value * empty_clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1947
name
static const char * name
Definition: tkMain.c:135
plpath
#define plpath
Definition: plplot.h:761
_wrap_plgriddata_texinfo
static const char * _wrap_plgriddata_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8944
_wrap_pl_setcontlabelformat_texinfo
static const char * _wrap_pl_setcontlabelformat_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6943
SWIG_AsVal_unsigned_SS_int
SWIGINTERN int SWIG_AsVal_unsigned_SS_int(octave_value obj, unsigned int *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:3345
swig_converter_func
void *(* swig_converter_func)(void *, int *)
Definition: plplot_octaveOCTAVE_wrap.cxx:459
SWIG_From_double
SWIGINTERNINLINE octave_value SWIG_From_double(double value)
Definition: plplot_octaveOCTAVE_wrap.cxx:2855
SWIG_init_user
static bool SWIG_init_user(octave_swig_type *module_ns)
Definition: plplot_octaveOCTAVE_wrap.cxx:25695
octave_swig_type::members
member_map members
Definition: plplot_octaveOCTAVE_wrap.cxx:1105
_wrap_plsmin_texinfo
static const char * _wrap_plsmin_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4614
plplot::maxlen
integer(kind=private_plint), parameter, private maxlen
Definition: plplot.f90:48
fcnLabelFunc
octave_function * fcnLabelFunc
Definition: plplot_octaveOCTAVE_wrap.cxx:2664
_wrap_plsyax_texinfo
static const char * _wrap_plsyax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3664
plgxax
#define plgxax
Definition: plplot.h:748
swig_PLGraphicsIn_base_names
static const char * swig_PLGraphicsIn_base_names[]
Definition: plplot_octaveOCTAVE_wrap.cxx:16250
_wrap_plscmap0n
SWIGINTERN PyObject * _wrap_plscmap0n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10761
_wrap_plgpage
SWIGINTERN PyObject * _wrap_plgpage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7178
plsstrm
#define plsstrm
Definition: plplot.h:835
swig_typequery_usage
static const char *const swig_typequery_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25452
_wrap_plot3dc
SWIGINTERN PyObject * _wrap_plot3dc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9343
subclass_usage
static const char *const subclass_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25398
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:1108
plGetCursor
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
_wrap_plstyl
SWIGINTERN PyObject * _wrap_plstyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13412
octave_swig_type::string_value
virtual std::string string_value(bool force=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1666
octave_value_ref::operator*
octave_value operator*() const
Definition: plplot_octaveOCTAVE_wrap.cxx:2179
_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:25054
octave_swig_type::own
int own
Definition: plplot_octaveOCTAVE_wrap.cxx:1101
octave_swig_packed
Definition: plplot_octaveOCTAVE_wrap.cxx:2071
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
_wrap_plschr_texinfo
static const char * _wrap_plschr_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4642
plspage
#define plspage
Definition: plplot.h:831
_wrap_plstripa
SWIGINTERN PyObject * _wrap_plstripa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13079
_wrap_plGetCursor
SWIGINTERN PyObject * _wrap_plGetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15303
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:3223
plvpor
#define plvpor
Definition: plplot.h:860
_wrap_PLGraphicsIn_dX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4728
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:2887
_wrap_plOptUsage
SWIGINTERN PyObject * _wrap_plOptUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15234
swig_octave_member::is_global
bool is_global() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1004
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:3038
_wrap_plscompression
SWIGINTERN PyObject * _wrap_plscompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11494
_wrap_pltimefmt
SWIGINTERN PyObject * _wrap_pltimefmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13744
_wrap_plszax_texinfo
static const char * _wrap_plszax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5627
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:1965
_wrap_plscolbga_texinfo
static const char * _wrap_plscolbga_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10382
_wrap_plgvpd
SWIGINTERN PyObject * _wrap_plgvpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7501
swig_octave_class::type
swig_type_info ** type
Definition: plplot_octaveOCTAVE_wrap.cxx:1011
SWIGTYPE_p_double
#define SWIGTYPE_p_double
Definition: plplot_octaveOCTAVE_wrap.cxx:2438
_wrap_plSetOpt_texinfo
static const char * _wrap_plSetOpt_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6507
_wrap_plwind
SWIGINTERN PyObject * _wrap_plwind(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14163
SWIG_OverflowError
#define SWIG_OverflowError
Definition: plplot_octaveOCTAVE_wrap.cxx:858
_wrap_plptex
SWIGINTERN PyObject * _wrap_plptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10294
plmtex3
#define plmtex3
Definition: plplot.h:774
plerry
#define plerry
Definition: plplot.h:715
_wrap_PLGraphicsIn_wX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4802
_wrap_plinit
SWIGINTERN PyObject * _wrap_plinit(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7835
SWIG_GetModule
#define SWIG_GetModule(clientdata)
Definition: plplot_octaveOCTAVE_wrap.cxx:943
swig_module_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:354
plsyax
#define plsyax
Definition: plplot.h:852
SWIG_OK
#define SWIG_OK
Definition: plplot_octaveOCTAVE_wrap.cxx:407
_wrap_plhist
SWIGINTERN PyObject * _wrap_plhist(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7701
octave_swig_type::scalar_value
virtual double scalar_value(bool frc_str_conv=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1679
_wrap_pltimefmt_texinfo
static const char * _wrap_pltimefmt_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9219
_wrap_plspal1
SWIGINTERN PyObject * _wrap_plspal1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12683
plschr
#define plschr
Definition: plplot.h:790
plsdev
#define plsdev
Definition: plplot.h:806
_wrap_plmapline_texinfo
static const char * _wrap_plmapline_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6536
_wrap_plsdimap_texinfo
static const char * _wrap_plsdimap_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9116
_wrap_plsfci_texinfo
static const char * _wrap_plsfci_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10632
_wrap_plinit_texinfo
static const char * _wrap_plinit_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4673
_wrap_plstripa_texinfo
static const char * _wrap_plstripa_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6684
plgdev
#define plgdev
Definition: plplot.h:729
octave_value_ref
Definition: plplot_octaveOCTAVE_wrap.cxx:2168
PLGraphicsIn::dX
PLFLT dX
Definition: plplot.h:442
_wrap_plseed
SWIGINTERN PyObject * _wrap_plseed(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11770
octave_swig_ref::numeric_conversion_function
virtual type_conv_info numeric_conversion_function(void) const
Definition: plplot_octaveOCTAVE_wrap.cxx:2050
min
int min(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2496
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:3266
_wrap_plgxax
SWIGINTERN PyObject * _wrap_plgxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7605
_wrap_plgcmap1_range_texinfo
static const char * _wrap_plgcmap1_range_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5776
octave_swig_packed::DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
Definition: plplot_octaveOCTAVE_wrap.cxx:2156
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
SWIG_TypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_TypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplot_octaveOCTAVE_wrap.cxx:723
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:874
SWIG_RUNTIME_VERSION
#define SWIG_RUNTIME_VERSION
Definition: plplot_octaveOCTAVE_wrap.cxx:287
_wrap_plsori_texinfo
static const char * _wrap_plsori_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6208
_wrap_plspause
SWIGINTERN PyObject * _wrap_plspause(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12716
pllegend
#define pllegend
Definition: plplot.h:758
octave_swig_type::help_text
const char * help_text() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1382
_wrap_plstransform_texinfo
static const char * _wrap_plstransform_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4450
SWIG_POINTER_OWN
#define SWIG_POINTER_OWN
Definition: plplot_octaveOCTAVE_wrap.cxx:325
_wrap_plmap
SWIGINTERN PyObject * _wrap_plmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14242
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:2991
_wrap_plscmap1a_texinfo
static const char * _wrap_plscmap1a_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3537
octave_swig_ref::save_ascii
virtual bool save_ascii(std::ostream &os)
Definition: plplot_octaveOCTAVE_wrap.cxx:2004
SWIG_Octave_GetGlobalValue
SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2373
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:2360
_wrap_plgcol0a_texinfo
static const char * _wrap_plgcol0a_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4252
SWIGTYPE_p_PLGraphicsIn
#define SWIGTYPE_p_PLGraphicsIn
Definition: plplot_octaveOCTAVE_wrap.cxx:2436
_wrap_plcont
SWIGINTERN PyObject * _wrap_plcont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5827
_cvt_double_to
static void _cvt_double_to(FLOAT *out_arr, double *in_arr, unsigned n_el)
Definition: plplot_octaveOCTAVE_wrap.cxx:2562
SWIG_InstallUnaryOps
SWIGRUNTIME void SWIG_InstallUnaryOps(int tid)
Definition: plplot_octaveOCTAVE_wrap.cxx:2271
_wrap_plmesh
SWIGINTERN PyObject * _wrap_plmesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8920
plshade
#define plshade
Definition: plplot.h:820
plscompression
#define plscompression
Definition: plplot.h:805
octave_swig_packed::DECLARE_OCTAVE_ALLOCATOR
DECLARE_OCTAVE_ALLOCATOR
Definition: plplot_octaveOCTAVE_wrap.cxx:2154
plarc
#define plarc
Definition: plplot.h:693
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:1806
nameLabelFunc
std::string nameLabelFunc
Definition: plplot_octaveOCTAVE_wrap.cxx:2665
_wrap_plstripd_texinfo
static const char * _wrap_plstripd_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6794
octave_swig_type::cast
int cast(void **vptr, swig_type_info *type, int *_own, int flags)
Definition: plplot_octaveOCTAVE_wrap.cxx:1431
PLUNICODE
PLUINT PLUNICODE
Definition: plplot.h:201
_wrap_plfamadv
SWIGINTERN PyObject * _wrap_plfamadv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6380
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:1823
_wrap_plmeridians_texinfo
static const char * _wrap_plmeridians_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9660
SWIG_Octave_InstallFunction
SWIGINTERN bool SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name)
Definition: plplot_octaveOCTAVE_wrap.cxx:25352
octave_swig_type::is_string
virtual bool is_string() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1661
my_plvect
void my_plvect(const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr)
Definition: plplot_octaveOCTAVE_wrap.cxx:3190
_wrap_plmtex3_texinfo
static const char * _wrap_plmtex3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3480
octave_swig_packed::empty_clone
octave_base_value * empty_clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:2092
plot3dc
#define plot3dc
Definition: plplot.h:776
_wrap_plpoin_texinfo
static const char * _wrap_plpoin_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7279
SWIG_PropagateClientData
SWIGRUNTIME void SWIG_PropagateClientData(void)
Definition: plplot_octaveOCTAVE_wrap.cxx:25276
swig_octave_member::is_static
bool is_static() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1002
_wrap_plline
SWIGINTERN PyObject * _wrap_plline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8781
_wrap_plbox3
SWIGINTERN PyObject * _wrap_plbox3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5464
plot3dcl
#define plot3dcl
Definition: plplot.h:777
swig_octave_prereq_usage
static const char *const swig_octave_prereq_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25490
_wrap_plmapline
SWIGINTERN PyObject * _wrap_plmapline(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14326
pllsty
#define pllsty
Definition: plplot.h:763
SWIG_SystemError
#define SWIG_SystemError
Definition: plplot_octaveOCTAVE_wrap.cxx:861
swig_octave_member::get_method
octave_func get_method
Definition: plplot_octaveOCTAVE_wrap.cxx:998
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA
DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref")
plsmin
#define plsmin
Definition: plplot.h:829
plwind
#define plwind
Definition: plplot.h:864
plclear
#define plclear
Definition: plplot.h:701
plfill
#define plfill
Definition: plplot.h:717
plconfigtime
#define plconfigtime
Definition: plplot.h:705
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:3253
_wrap_plbin
SWIGINTERN PyObject * _wrap_plbin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5241
swig_octave_class
Definition: plplot_octaveOCTAVE_wrap.cxx:1009
plsurf3dl
#define plsurf3dl
Definition: plplot.h:848
_wrap_plsdev
SWIGINTERN PyObject * _wrap_plsdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11515
_wrap_plpoin3_texinfo
static const char * _wrap_plpoin3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10279
_wrap_plscmap1l
SWIGINTERN PyObject * _wrap_plscmap1l(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10942
octave_swig_ref::get_ptr
octave_swig_type * get_ptr() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1941
octave_swig_type::is_object
virtual bool is_object() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1657
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
plbtime
#define plbtime
Definition: plplot.h:699
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
_wrap_plmesh_texinfo
static const char * _wrap_plmesh_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7380
_wrap_plctime
SWIGINTERN PyObject * _wrap_plctime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5968
pl_setcontlabelparam
#define pl_setcontlabelparam
Definition: plplot.h:691
SWIGTYPE_p_p_char
#define SWIGTYPE_p_p_char
Definition: plplot_octaveOCTAVE_wrap.cxx:2443
_wrap_plpsty
SWIGINTERN PyObject * _wrap_plpsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10273
plscolbg
#define plscolbg
Definition: plplot.h:802
swig_type_info::dcast
swig_dycast_func dcast
Definition: plplotluacLUA_wrap.c:331
_swigt__p_double
static swig_type_info _swigt__p_double
Definition: plplot_octaveOCTAVE_wrap.cxx:25029
swig_type_info::cast
struct swig_cast_info * cast
Definition: plplotluacLUA_wrap.c:332
_wrap_plsstrm_texinfo
static const char * _wrap_plsstrm_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5515
octave_swig_packed::print
void print(std::ostream &os, bool pr_as_read_syntax=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:2103
swig_this
static PyObject * swig_this
Definition: plplotcPYTHON_wrap.c:2242
plfont
#define plfont
Definition: plplot.h:720
_wrap_plspage
SWIGINTERN PyObject * _wrap_plspage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12593
SWIG_Octave_LoadModule
SWIGINTERN bool SWIG_Octave_LoadModule(std::string name)
Definition: plplot_octaveOCTAVE_wrap.cxx:25309
plstyl
#define plstyl
Definition: plplot.h:846
_wrap_plgspa_texinfo
static const char * _wrap_plgspa_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8407
PL_MAXKEY
#define PL_MAXKEY
Definition: plplot.h:408
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:1144
SWIG_OLDOBJ
#define SWIG_OLDOBJ
Definition: plplot_octaveOCTAVE_wrap.cxx:420
_wrap_plsdidev
SWIGINTERN PyObject * _wrap_plsdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11539
plpoly3
#define plpoly3
Definition: plplot.h:782
SWIGINTERN
#define SWIGINTERN
Definition: plplot_octaveOCTAVE_wrap.cxx:104
plimage
#define plimage
Definition: plplot.h:753
SWIG_Octave_GetModule
SWIGRUNTIME swig_module_info * SWIG_Octave_GetModule(void *clientdata)
Definition: plplot_octaveOCTAVE_wrap.cxx:2409
swig_cast_info::type
swig_type_info * type
Definition: plplotluacLUA_wrap.c:339
SWIG_TypeQuery
#define SWIG_TypeQuery(name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2447
Swig
Definition: plplot_octaveOCTAVE_wrap.cxx:966
_wrap_PLGraphicsIn_subwindow_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4483
SWIG_MangledTypeQueryModule
SWIGRUNTIME swig_type_info * SWIG_MangledTypeQueryModule(swig_module_info *start, swig_module_info *end, const char *name)
Definition: plplot_octaveOCTAVE_wrap.cxx:678
plfontld
#define plfontld
Definition: plplot.h:721
_wrap_plenv0_texinfo
static const char * _wrap_plenv0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4927
octave_swig_type::print
void print(std::ostream &os, bool pr_as_read_syntax=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1880
plscolbga
#define plscolbga
Definition: plplot.h:803
octave_swig_type::cpp_ptr::cpp_ptr
cpp_ptr(void *_ptr)
Definition: plplot_octaveOCTAVE_wrap.cxx:1093
swig_octave_member::flags
int flags
Definition: plplot_octaveOCTAVE_wrap.cxx:1000
_wrap_PLGraphicsIn_button_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4461
plbin
#define plbin
Definition: plplot.h:695
plTranslateCursor
PLINT plTranslateCursor(PLGraphicsIn *plg)
Definition: plpage.c:259
plsdiori
#define plsdiori
Definition: plplot.h:809
_wrap_plend1
SWIGINTERN PyObject * _wrap_plend1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6086
_wrap_plpsty_texinfo
static const char * _wrap_plpsty_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10658
octave_swig_ref::DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA
Definition: plplot_octaveOCTAVE_wrap.cxx:2064
octave_swig_type::map_value
virtual Octave_map map_value() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1722
_wrap_pljoin
SWIGINTERN PyObject * _wrap_pljoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7847
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
plmeridians
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
plparseopts
#define plparseopts
Definition: plplot.h:778
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
plsym
#define plsym
Definition: plplot.h:853
plscmap1
#define plscmap1
Definition: plplot.h:794
octave_swig_type::member_map
std::map< std::string, member_value_pair > member_map
Definition: plplot_octaveOCTAVE_wrap.cxx:1104
_wrap_plbtime
SWIGINTERN PyObject * _wrap_plbtime(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5299
plinit
#define plinit
Definition: plplot.h:755
plctime
#define plctime
Definition: plplot.h:708
pltimefmt
#define pltimefmt
Definition: plplot.h:856
plscmap1n
#define plscmap1n
Definition: plplot.h:798
_wrap_plscmap1
SWIGINTERN PyObject * _wrap_plscmap1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10782
_wrap_plsfont
SWIGINTERN PyObject * _wrap_plsfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11933
_wrap_plbop
SWIGINTERN PyObject * _wrap_plbop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5380
_wrap_plgfont_texinfo
static const char * _wrap_plgfont_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10007
swig_octave_class::destructor
octave_func destructor
Definition: plplot_octaveOCTAVE_wrap.cxx:1015
plbop
#define plbop
Definition: plplot.h:696
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
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
swig_octave_class::director
int director
Definition: plplot_octaveOCTAVE_wrap.cxx:1012
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:1784
plplotc.pltr0
def pltr0
Definition: plplotc.py:101
error
static int error
Definition: plcont.c:61
_swigt__p_p_char
static swig_type_info _swigt__p_p_char
Definition: plplot_octaveOCTAVE_wrap.cxx:25034
plsdiplt
#define plsdiplt
Definition: plplot.h:810
swig_module_info
struct swig_module_info swig_module_info
plsvect
#define plsvect
Definition: plplot.h:849
plscmap1a
#define plscmap1a
Definition: plplot.h:795
plssub
#define plssub
Definition: plplot.h:836
octave_swig_packed::is_defined
bool is_defined() const
Definition: plplot_octaveOCTAVE_wrap.cxx:2096
c_plmesh
void c_plmesh(PLFLT_VECTOR x, PLFLT_VECTOR y, PLFLT_MATRIX z, PLINT nx, PLINT ny, PLINT opt)
Definition: plot3d.c:118
_wrap_plcont_texinfo
static const char * _wrap_plcont_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5349
octave_swig_type::swig_member_const_iterator
member_map::const_iterator swig_member_const_iterator
Definition: plplot_octaveOCTAVE_wrap.cxx:1427
_wrap_plstring_texinfo
static const char * _wrap_plstring_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4820
_wrap_plsmin
SWIGINTERN PyObject * _wrap_plsmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12542
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:3021
_wrap_PLGraphicsIn_string_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4566
_wrap_plmtex3
SWIGINTERN PyObject * _wrap_plmtex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9188
_wrap_plpoin3
SWIGINTERN PyObject * _wrap_plpoin3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10067
_wrap_plgcol0
SWIGINTERN PyObject * _wrap_plgcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6654
SWIG_ConvertPtr
#define SWIG_ConvertPtr(obj, pptr, type, flags)
Definition: plplot_octaveOCTAVE_wrap.cxx:930
PLPointer
void * PLPointer
Definition: plplot.h:209
plspal1
#define plspal1
Definition: plplot.h:833
plsetopt
#define plsetopt
Definition: plplot.h:815
_wrap_plenv
SWIGINTERN PyObject * _wrap_plenv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6098
plmeshc
#define plmeshc
Definition: plplot.h:771
_wrap_plshades
SWIGINTERN PyObject * _wrap_plshades(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11972
_wrap_plbox3_texinfo
static const char * _wrap_plbox3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8626
plgcompression
#define plgcompression
Definition: plplot.h:728
SWIG_UnpackData
SWIGRUNTIME const char * SWIG_UnpackData(const char *c, void *ptr, size_t sz)
Definition: plplot_octaveOCTAVE_wrap.cxx:768
_wrap_plot3d
SWIGINTERN PyObject * _wrap_plot3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9251
_wrap_plpath
SWIGINTERN PyObject * _wrap_plpath(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9952
SWIG_name
#define SWIG_name
Definition: plplot_octaveOCTAVE_wrap.cxx:17
plszax
#define plszax
Definition: plplot.h:854
plvsta
#define plvsta
Definition: plplot.h:861
_wrap_PLGraphicsIn_state_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4357
SWIG_pchar_descriptor
SWIGINTERN swig_type_info * SWIG_pchar_descriptor(void)
Definition: plplot_octaveOCTAVE_wrap.cxx:3399
_wrap_PLGraphicsIn_wY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4884
_wrap_plgfam
SWIGINTERN PyObject * _wrap_plgfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7029
_wrap_plgdidev_texinfo
static const char * _wrap_plgdidev_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4786
SWIG_TypeCheck
SWIGRUNTIME swig_cast_info * SWIG_TypeCheck(const char *c, swig_type_info *ty)
Definition: plplot_octaveOCTAVE_wrap.cxx:542
_n_dims
static int _n_dims(const octave_value &o_obj)
Definition: plplot_octaveOCTAVE_wrap.cxx:2522
octave_value_ref::j
int j
Definition: plplot_octaveOCTAVE_wrap.cxx:2170
plgpage
#define plgpage
Definition: plplot.h:739
plaxes
#define plaxes
Definition: plplot.h:694
plsori
#define plsori
Definition: plplot.h:830
_wrap_plpoin
SWIGINTERN PyObject * _wrap_plpoin(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10009
_wrap_plfont
SWIGINTERN PyObject * _wrap_plfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6580
_wrap_pllightsource
SWIGINTERN PyObject * _wrap_pllightsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8742
_wrap_pleop
SWIGINTERN PyObject * _wrap_pleop(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6230
SWIG_AsVal_unsigned_SS_long
SWIGINTERN int SWIG_AsVal_unsigned_SS_long(const octave_value &ov, unsigned long *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:3314
_wrap_plgdidev
SWIGINTERN PyObject * _wrap_plgdidev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6903
_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:25032
SWIG_AsVal_int
SWIGINTERN int SWIG_AsVal_int(octave_value obj, int *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:2783
plgdiplt
#define plgdiplt
Definition: plplot.h:732
_wrap_plmtex
SWIGINTERN PyObject * _wrap_plmtex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9125
SWIG_TypeClientData
SWIGRUNTIME void SWIG_TypeClientData(swig_type_info *ti, void *clientdata)
Definition: plplot_octaveOCTAVE_wrap.cxx:648
_wrap_plvsta
SWIGINTERN PyObject * _wrap_plvsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14019
SWIG_name_usage
static const char *const SWIG_name_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25507
plscmap0a
#define plscmap0a
Definition: plplot.h:792
SWIG_TypeError
#define SWIG_TypeError
Definition: plplot_octaveOCTAVE_wrap.cxx:856
PLcGrid2::ny
PLINT ny
Definition: plplot.h:521
SWIG_UnpackVoidPtr
SWIGRUNTIME const char * SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name)
Definition: plplot_octaveOCTAVE_wrap.cxx:807
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:2798
plfamadv
#define plfamadv
Definition: plplot.h:716
_wrap_plarc_texinfo
static const char * _wrap_plarc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5837
octave_swig_type::cpp_ptr::destroyed
bool destroyed
Definition: plplot_octaveOCTAVE_wrap.cxx:1092
_wrap_plscol0a
SWIGINTERN PyObject * _wrap_plscol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11329
swig_module_info::size
size_t size
Definition: plplotluacLUA_wrap.c:350
_wrap_plwind_texinfo
static const char * _wrap_plwind_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3858
SWIG_AsCharArray
SWIGINTERN int SWIG_AsCharArray(octave_value obj, char *val, size_t size)
Definition: plplot_octaveOCTAVE_wrap.cxx:3374
octave_set_immutable
SWIGRUNTIME octave_value_list octave_set_immutable(const octave_value_list &args, int nargout)
Definition: plplot_octaveOCTAVE_wrap.cxx:2163
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:2334
plend
#define plend
Definition: plplot.h:709
_wrap_plglevel
SWIGINTERN PyObject * _wrap_plglevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7156
_wrap_plgdiori_texinfo
static const char * _wrap_plgdiori_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8024
SWIG_Octave_AppendOutput
SWIGRUNTIME octave_value_list * SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov)
Definition: plplot_octaveOCTAVE_wrap.cxx:884
plplot::PLGraphicsIn
alias _N2 PLGraphicsIn
Definition: plplot.d:1262
_wrap_plstring
SWIGINTERN PyObject * _wrap_plstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12937
_wrap_plstring3_texinfo
static const char * _wrap_plstring3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9752
_wrap_plmkstrm
SWIGINTERN PyObject * _wrap_plmkstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9103
_wrap_new_PLGraphicsIn
SWIGINTERN PyObject * _wrap_new_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4906
_wrap_plsfont_texinfo
static const char * _wrap_plsfont_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7844
_wrap_plsyax
SWIGINTERN PyObject * _wrap_plsyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13614
_swigc__p_double
static swig_cast_info _swigc__p_double[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25051
mapform_func
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
Definition: plplot_octaveOCTAVE_wrap.cxx:2607
octave_swig_type::find_member
member_value_pair * find_member(const std::string &name, bool insert_if_not_found)
Definition: plplot_octaveOCTAVE_wrap.cxx:1131
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:1780
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:2978
Xlen
static PLINT Xlen
Definition: plplot_octaveOCTAVE_wrap.cxx:2483
plgfont
#define plgfont
Definition: plplot.h:737
plplotc.plSetUsage
def plSetUsage
Definition: plplotc.py:8456
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:3005
plend1
#define plend1
Definition: plplot.h:710
_wrap_plgcompression_texinfo
static const char * _wrap_plgcompression_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7756
PLINT
int PLINT
Definition: plplot.h:181
plenv0
#define plenv0
Definition: plplot.h:712
_wrap_PLGraphicsIn_type_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4275
_wrap_plgcolbga
SWIGINTERN PyObject * _wrap_plgcolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6808
SWIG_Octave_SetModule
SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:2421
plgdiori
#define plgdiori
Definition: plplot.h:731
_wrap_plgyax_texinfo
static const char * _wrap_plgyax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7513
SWIG_InstallBinaryOps
SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2)
Definition: plplot_octaveOCTAVE_wrap.cxx:2283
plshades
#define plshades
Definition: plplot.h:824
_wrap_plgstrm_texinfo
static const char * _wrap_plgstrm_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6422
PLBOOL
PLINT PLBOOL
Definition: plplot.h:204
_swigt__p_char
static swig_type_info _swigt__p_char
Definition: plplot_octaveOCTAVE_wrap.cxx:25028
_wrap_plscmap0a_texinfo
static const char * _wrap_plscmap0a_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9045
ct_func
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:2606
_wrap_plstyl_texinfo
static const char * _wrap_plstyl_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5424
_wrap_pleop_texinfo
static const char * _wrap_pleop_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10476
_wrap_plscmap1_range
SWIGINTERN PyObject * _wrap_plscmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11219
plssym
#define plssym
Definition: plplot.h:837
_wrap_plgcol0_texinfo
static const char * _wrap_plgcol0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3694
octave_func
octave_value_list(* octave_func)(const octave_value_list &, int)
Definition: plplot_octaveOCTAVE_wrap.cxx:963
_wrap_plgchr_texinfo
static const char * _wrap_plgchr_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8750
PLcGrid2::yg
PLFLT_NC_MATRIX yg
Definition: plplot.h:520
_wrap_plbox_texinfo
static const char * _wrap_plbox_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4700
pljoin
#define pljoin
Definition: plplot.h:756
plgzax
#define plgzax
Definition: plplot.h:750
_wrap_PLGraphicsIn_dX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4698
_swigc__p_p_char
static swig_cast_info _swigc__p_p_char[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25056
octave_swig_packed::save_binary
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
Definition: plplot_octaveOCTAVE_wrap.cxx:2119
_wrap_plgdev
SWIGINTERN PyObject * _wrap_plgdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6882
octave_swig_ref::print
void print(std::ostream &os, bool pr_as_read_syntax=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:2046
_wrap_plsvpa
SWIGINTERN PyObject * _wrap_plsvpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13536
_wrap_plgfci_texinfo
static const char * _wrap_plgfci_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7064
SWIG_From_long
SWIGINTERNINLINE octave_value SWIG_From_long(long value)
Definition: plplot_octaveOCTAVE_wrap.cxx:2842
plgfam
#define plgfam
Definition: plplot.h:734
fcnMapForm
octave_function * fcnMapForm
Definition: plplot_octaveOCTAVE_wrap.cxx:2614
_wrap_pl_setcontlabelformat
SWIGINTERN PyObject * _wrap_pl_setcontlabelformat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4968
octave_swig_ref::save_binary
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
Definition: plplot_octaveOCTAVE_wrap.cxx:2010
_wrap_plGetCursor_texinfo
static const char * _wrap_plGetCursor_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6633
_wrap_pllightsource_texinfo
static const char * _wrap_pllightsource_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7882
octave_swig_type::make_value_hack
static octave_value make_value_hack(const octave_base_value &x)
Definition: plplot_octaveOCTAVE_wrap.cxx:1270
_wrap_plgver_texinfo
static const char * _wrap_plgver_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6919
PLcGrid::ny
PLINT ny
Definition: plplot.h:509
plgdidev
#define plgdidev
Definition: plplot.h:730
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:3129
SWIG_Octave_NewPointerObj
SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags)
Definition: plplot_octaveOCTAVE_wrap.cxx:2323
_wrap_plgra_texinfo
static const char * _wrap_plgra_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3605
_wrap_plmapstring
SWIGINTERN PyObject * _wrap_plmapstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14435
plstar
#define plstar
Definition: plplot.h:838
_wrap_plstring3
SWIGINTERN PyObject * _wrap_plstring3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12998
_wrap_plsvect_texinfo
static const char * _wrap_plsvect_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5264
SWIG_TypeEquiv
SWIGRUNTIME int SWIG_TypeEquiv(const char *nb, const char *tb)
Definition: plplot_octaveOCTAVE_wrap.cxx:534
_wrap_plsfnam_texinfo
static const char * _wrap_plsfnam_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9342
_wrap_plgfam_texinfo
static const char * _wrap_plgfam_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5296
fcnCoordTrans
octave_function * fcnCoordTrans
Definition: plplot_octaveOCTAVE_wrap.cxx:2698
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
octave_swig_ref::load_ascii
virtual bool load_ascii(std::istream &is)
Definition: plplot_octaveOCTAVE_wrap.cxx:2007
octave_swig_type::swig_members_begin
swig_member_const_iterator swig_members_begin()
Definition: plplot_octaveOCTAVE_wrap.cxx:1428
_wrap_plerry
SWIGINTERN PyObject * _wrap_plerry(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6311
plcpstrm
#define plcpstrm
Definition: plplot.h:707
_wrap_plspage_texinfo
static const char * _wrap_plspage_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7167
SWIG_PackVoidPtr
SWIGRUNTIME char * SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz)
Definition: plplot_octaveOCTAVE_wrap.cxx:796
_wrap_plparseopts
SWIGINTERN PyObject * _wrap_plparseopts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9835
plimagefr
#define plimagefr
Definition: plplot.h:754
swig_octave_class::constructor
octave_func constructor
Definition: plplot_octaveOCTAVE_wrap.cxx:1013
plcalc_world
#define plcalc_world
Definition: plplot.h:700
_wrap_plxormod
SWIGINTERN PyObject * _wrap_plxormod(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14211
_wrap_plstripc_texinfo
static const char * _wrap_plstripc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6715
swig_octave_class::name
const char * name
Definition: plplot_octaveOCTAVE_wrap.cxx:1010
octave_swig_type::assign
void assign(const std::string &name, const swig_octave_member *m)
Definition: plplot_octaveOCTAVE_wrap.cxx:1489
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:3072
_swigc__p_char
static swig_cast_info _swigc__p_char[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25050
_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:25030
octave_swig_type::assign
void assign(const std::string &name, const octave_value &ov)
Definition: plplot_octaveOCTAVE_wrap.cxx:1485
plsfnam
#define plsfnam
Definition: plplot.h:818
_wrap_plreplot_texinfo
static const char * _wrap_plreplot_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4287
SWIG_TypeName
SWIGRUNTIMEINLINE const char * SWIG_TypeName(const swig_type_info *ty)
Definition: plplot_octaveOCTAVE_wrap.cxx:618
plhist
#define plhist
Definition: plplot.h:751
_wrap_plfill3
SWIGINTERN PyObject * _wrap_plfill3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6441
octave_swig_ref::ptr
octave_swig_type * ptr
Definition: plplot_octaveOCTAVE_wrap.cxx:1933
_wrap_plsdimap
SWIGINTERN PyObject * _wrap_plsdimap(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11587
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:3243
_wrap_plgcol0a
SWIGINTERN PyObject * _wrap_plgcol0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6705
octave_swig_ref::octave_swig_ref
octave_swig_ref(octave_swig_type *_ptr=0)
Definition: plplot_octaveOCTAVE_wrap.cxx:1935
swig_type_usage
static const char *const swig_type_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25434
_wrap_plsmaj_texinfo
static const char * _wrap_plsmaj_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6891
SWIG_TypeNewClientData
SWIGRUNTIME void SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata)
Definition: plplot_octaveOCTAVE_wrap.cxx:664
PLcGrid
Definition: plplot.h:506
octave_swig_ref::is_map
virtual bool is_map() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1956
Ylen
static PLINT Ylen
Definition: plplot_octaveOCTAVE_wrap.cxx:2483
_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:25052
_wrap_plResetOpts
SWIGINTERN PyObject * _wrap_plResetOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15186
_wrap_plSetUsage
SWIGINTERN PyObject * _wrap_plSetUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15198
_wrap_plslabelfunc
SWIGINTERN PyObject * _wrap_plslabelfunc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12379
_wrap_plscmap1_range_texinfo
static const char * _wrap_plscmap1_range_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5802
SWIG_AsCharPtrAndSize
SWIGINTERN int SWIG_AsCharPtrAndSize(octave_value ov, char **cptr, size_t *psize, int *alloc)
Definition: plplot_octaveOCTAVE_wrap.cxx:2812
plgchr
#define plgchr
Definition: plplot.h:722
SWIG_exception_fail
#define SWIG_exception_fail(code, msg)
Definition: plplot_octaveOCTAVE_wrap.cxx:2428
label_func
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:2609
_wrap_plsurf3d
SWIGINTERN PyObject * _wrap_plsurf3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9589
swig_module_info::next
struct swig_module_info * next
Definition: plplotluacLUA_wrap.c:351
_wrap_PLGraphicsIn_keysym_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4409
plsdidev
#define plsdidev
Definition: plplot.h:807
SWIG_SetModule
#define SWIG_SetModule(clientdata, pointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:944
plspal0
#define plspal0
Definition: plplot.h:832
swig_octave_member::method
octave_func method
Definition: plplot_octaveOCTAVE_wrap.cxx:997
_wrap_plvasp_texinfo
static const char * _wrap_plvasp_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9317
SWIG_ERROR
#define SWIG_ERROR
Definition: plplot_octaveOCTAVE_wrap.cxx:408
_wrap_plvsta_texinfo
static const char * _wrap_plvsta_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3586
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:2369
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:3153
_wrap_plscompression_texinfo
static const char * _wrap_plscompression_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7723
plfill3
#define plfill3
Definition: plplot.h:718
_wrap_plmeridians
SWIGINTERN PyObject * _wrap_plmeridians(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14797
octave_swig_type::subsref
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
Definition: plplot_octaveOCTAVE_wrap.cxx:1513
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
pltr_func
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:2605
_wrap_plgyax
SWIGINTERN PyObject * _wrap_plgyax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7637
octave_swig_ref::dims
dim_vector dims(void) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1950
swig_module
static swig_module_info swig_module
Definition: plplot_octaveOCTAVE_wrap.cxx:2446
SWIG_ErrorType
SWIGRUNTIME octave_value SWIG_ErrorType(int code)
Definition: plplot_octaveOCTAVE_wrap.cxx:889
swig_cast_info::converter
swig_converter_func converter
Definition: plplotluacLUA_wrap.c:340
_wrap_PLGraphicsIn_pY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4646
_wrap_plfill
SWIGINTERN PyObject * _wrap_plfill(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6392
octave_swig_type::as_value
octave_value as_value()
Definition: plplot_octaveOCTAVE_wrap.cxx:1363
_wrap_plgdev_texinfo
static const char * _wrap_plgdev_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6660
_wrap_plsfam_texinfo
static const char * _wrap_plsfam_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7087
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:3198
_wrap_plsdidev_texinfo
static const char * _wrap_plsdidev_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4332
plseed
#define plseed
Definition: plplot.h:813
plplotc.plOptUsage
def plOptUsage
Definition: plplotc.py:8460
PLcGrid::yg
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:508
SWIGTYPE_p_unsigned_int
#define SWIGTYPE_p_unsigned_int
Definition: plplot_octaveOCTAVE_wrap.cxx:2444
plstring
#define plstring
Definition: plplot.h:841
plstransform
#define plstransform
Definition: plplot.h:840
_wrap_plgchr
SWIGINTERN PyObject * _wrap_plgchr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6622
plvect
#define plvect
Definition: plplot.h:858
Swig::swig_value_deref
SWIGRUNTIME octave_swig_type * swig_value_deref(octave_value ov)
Definition: plplot_octaveOCTAVE_wrap.cxx:2191
SWIG_as_voidptr
#define SWIG_as_voidptr(a)
Definition: plplot_octaveOCTAVE_wrap.cxx:2457
_wrap_plwidth_texinfo
static const char * _wrap_plwidth_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7936
_wrap_plgradient_texinfo
static const char * _wrap_plgradient_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7961
_wrap_plgradient
SWIGINTERN PyObject * _wrap_plgradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6510
SWIG_DelNewMask
#define SWIG_DelNewMask(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:425
SWIG_ArgError
#define SWIG_ArgError(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:410
_wrap_plend1_texinfo
static const char * _wrap_plend1_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7495
octave_swig_type::type_ptr_pair
std::pair< const swig_type_info *, cpp_ptr > type_ptr_pair
Definition: plplot_octaveOCTAVE_wrap.cxx:1095
_wrap_plspal0_texinfo
static const char * _wrap_plspal0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5458
octave_swig_type::is_owned
bool is_owned() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1467
plplotc.plResetOpts
def plResetOpts
Definition: plplotc.py:8452
_wrap_plsxax_texinfo
static const char * _wrap_plsxax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8052
_wrap_plscmap1_texinfo
static const char * _wrap_plscmap1_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4485
PLcGrid2
Definition: plplot.h:518
plscmap1la
#define plscmap1la
Definition: plplot.h:797
plgfnam
#define plgfnam
Definition: plplot.h:736
_wrap_plssub_texinfo
static const char * _wrap_plssub_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4425
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:3209
_wrap_plpat_texinfo
static const char * _wrap_plpat_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5937
_wrap_plscolbga
SWIGINTERN PyObject * _wrap_plscolbga(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11425
plcont
#define plcont
Definition: plplot.h:706
plsxax
#define plsxax
Definition: plplot.h:851
plstart
#define plstart
Definition: plplot.h:839
octave_swig_ref::subsref
virtual octave_value subsref(const std::string &ops, const std::list< octave_value_list > &idx)
Definition: plplot_octaveOCTAVE_wrap.cxx:1959
_wrap_plshades_texinfo
static const char * _wrap_plshades_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8114
_cvt_to_double
static void _cvt_to_double(FLOAT *arr, double *d_arr, unsigned n_el)
Definition: plplot_octaveOCTAVE_wrap.cxx:2586
_wrap_plgvpd_texinfo
static const char * _wrap_plgvpd_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7348
defined_func
PLINT(* defined_func)(PLFLT, PLFLT)
Definition: plplot_octaveOCTAVE_wrap.cxx:2603
pleop
#define pleop
Definition: plplot.h:713
plmesh
#define plmesh
Definition: plplot.h:770
plhlsrgb
#define plhlsrgb
Definition: plplot.h:752
swig_module_info::types
swig_type_info ** types
Definition: plplotluacLUA_wrap.c:349
nameCoordTrans
std::string nameCoordTrans
Definition: plplot_octaveOCTAVE_wrap.cxx:2699
SWIGRUNTIME
#define SWIGRUNTIME
Definition: plplot_octaveOCTAVE_wrap.cxx:308
_wrap_plgvpw_texinfo
static const char * _wrap_plgvpw_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8082
Swig::swig_value_ref
SWIGRUNTIME octave_base_value * swig_value_ref(octave_swig_type *ost)
Definition: plplot_octaveOCTAVE_wrap.cxx:2187
SWIG_IsNewObj
#define SWIG_IsNewObj(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:426
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:3282
plsmaj
#define plsmaj
Definition: plplot.h:826
PLcGrid2::nx
PLINT nx
Definition: plplot.h:521
octave_swig_type::swig_type_name
std::string swig_type_name() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1391
_wrap_plsym
SWIGINTERN PyObject * _wrap_plsym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13644
_wrap_plgdiplt_texinfo
static const char * _wrap_plgdiplt_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9821
_wrap_plvpor_texinfo
static const char * _wrap_plvpor_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5538
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:1224
SWIG_AsVal_double
SWIGINTERN int SWIG_AsVal_double(const octave_value &ov, double *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:2873
_wrap_plflush_texinfo
static const char * _wrap_plflush_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8007
_wrap_plfontld
SWIGINTERN PyObject * _wrap_plfontld(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6601
_wrap_pltext
SWIGINTERN PyObject * _wrap_pltext(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13732
_wrap_plgfnam
SWIGINTERN PyObject * _wrap_plgfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7093
mapform_octave
void mapform_octave(PLINT n, PLFLT *x, PLFLT *y)
Definition: plplot_octaveOCTAVE_wrap.cxx:2617
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:3029
_wrap_plfill3_texinfo
static const char * _wrap_plfill3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6003
_wrap_plenv0
SWIGINTERN PyObject * _wrap_plenv0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6164
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:3107
SWIGTYPE_p_int
#define SWIGTYPE_p_int
Definition: plplot_octaveOCTAVE_wrap.cxx:2442
plcol1
#define plcol1
Definition: plplot.h:703
xform
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plplot_octaveOCTAVE_wrap.cxx:2917
pllab
#define pllab
Definition: plplot.h:757
pllightsource
#define pllightsource
Definition: plplot.h:759
SWIGINTERNINLINE
#define SWIGINTERNINLINE
Definition: plplot_octaveOCTAVE_wrap.cxx:109
SWIG_as_voidptrptr
#define SWIG_as_voidptrptr(a)
Definition: plplot_octaveOCTAVE_wrap.cxx:2458
_wrap_PLGraphicsIn_pX_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4594
_wrap_plprec_texinfo
static const char * _wrap_plprec_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7219
SWIG_TMPOBJ
#define SWIG_TMPOBJ
Definition: plplot_octaveOCTAVE_wrap.cxx:422
plbox
#define plbox
Definition: plplot.h:697
_wrap_plstar_texinfo
static const char * _wrap_plstar_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7033
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:2076
_wrap_plseed_texinfo
static const char * _wrap_plseed_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3726
_wrap_plgfont
SWIGINTERN PyObject * _wrap_plgfont(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7114
SWIG_TYPE_TABLE_NAME
#define SWIG_TYPE_TABLE_NAME
Definition: plplot_octaveOCTAVE_wrap.cxx:295
octave_swig_packed::type
swig_type_info * type
Definition: plplot_octaveOCTAVE_wrap.cxx:2072
pltext
#define pltext
Definition: plplot.h:855
octave_swig_type::save_ascii
virtual bool save_ascii(std::ostream &os)
Definition: plplot_octaveOCTAVE_wrap.cxx:1739
octave_swig_packed::save_ascii
virtual bool save_ascii(std::ostream &os)
Definition: plplot_octaveOCTAVE_wrap.cxx:2111
SWIG_FromCharPtrAndSize
SWIGINTERNINLINE octave_value SWIG_FromCharPtrAndSize(const char *carray, size_t size)
Definition: plplot_octaveOCTAVE_wrap.cxx:3412
octave_swig_type::dims
dim_vector dims(void) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1312
_wrap_plptex_texinfo
static const char * _wrap_plptex_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5574
_wrap_plvpor
SWIGINTERN PyObject * _wrap_plvpor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13971
swig_cast_info
Definition: plplotluacLUA_wrap.c:338
_wrap_plsdiori
SWIGINTERN PyObject * _wrap_plsdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11653
plwidth
#define plwidth
Definition: plplot.h:863
_swigt__p_int
static swig_type_info _swigt__p_int
Definition: plplot_octaveOCTAVE_wrap.cxx:25033
plgver
#define plgver
Definition: plplot.h:745
octave_swig_ref::is_string
virtual bool is_string() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1971
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:1751
_wrap_plline3
SWIGINTERN PyObject * _wrap_plline3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8830
_wrap_plscmap0n_texinfo
static const char * _wrap_plscmap0n_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9630
_wrap_plcol1
SWIGINTERN PyObject * _wrap_plcol1(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5695
_wrap_plscolbg_texinfo
static const char * _wrap_plscolbg_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9551
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:2037
plscol0a
#define plscol0a
Definition: plplot.h:801
plptex3
#define plptex3
Definition: plplot.h:786
octave_swig_type::save_binary
virtual bool save_binary(std::ostream &os, bool &save_as_floats)
Definition: plplot_octaveOCTAVE_wrap.cxx:1747
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:2013
plsdiplz
#define plsdiplz
Definition: plplot.h:811
PLGraphicsIn::keysym
unsigned int keysym
Definition: plplot.h:437
value
static PLFLT value(double n1, double n2, double hue)
Definition: plctrl.c:1219
_wrap_plvpas
SWIGINTERN PyObject * _wrap_plvpas(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13914
_wrap_plsdev_texinfo
static const char * _wrap_plsdev_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9526
octave_swig_type::incref
void incref()
Definition: plplot_octaveOCTAVE_wrap.cxx:1368
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:2123
ct_octave
void ct_octave(PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data)
Definition: plplot_octaveOCTAVE_wrap.cxx:2701
swig_octave_class::constructor_doc
const char * constructor_doc
Definition: plplot_octaveOCTAVE_wrap.cxx:1014
SWIG_OCTAVE_BOUND_FUNC
#define SWIG_OCTAVE_BOUND_FUNC(func, args)
Definition: plplot_octaveOCTAVE_wrap.cxx:1079
plspause
#define plspause
Definition: plplot.h:834
swig_octave_class::base
const swig_type_info ** base
Definition: plplot_octaveOCTAVE_wrap.cxx:1018
swig_types
static swig_type_info * swig_types[10]
Definition: plplot_octaveOCTAVE_wrap.cxx:2445
_wrap_PLGraphicsIn_pY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4676
_wrap_plbtime_texinfo
static const char * _wrap_plbtime_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6367
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
_wrap_plgcmap1_range
SWIGINTERN PyObject * _wrap_plgcmap1_range(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11249
plline3
#define plline3
Definition: plplot.h:762
_wrap_PLGraphicsIn_pX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_pX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4624
plstripd
#define plstripd
Definition: plplot.h:845
plgfci
#define plgfci
Definition: plplot.h:735
plgspa
#define plgspa
Definition: plplot.h:743
plgcolbg
#define plgcolbg
Definition: plplot.h:726
_wrap_plot3dcl_texinfo
static const char * _wrap_plot3dcl_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3748
SWIG_Octave_SetGlobalValue
SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value &value)
Definition: plplot_octaveOCTAVE_wrap.cxx:2382
plstripc
#define plstripc
Definition: plplot.h:844
_wrap_plgzax
SWIGINTERN PyObject * _wrap_plgzax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7669
DEFUN_DLD
DEFUN_DLD(subclass, args, nargout, subclass_usage)
Definition: plplot_octaveOCTAVE_wrap.cxx:25406
swig_type_info::str
const char * str
Definition: plplotluacLUA_wrap.c:330
_wrap_plstart
SWIGINTERN PyObject * _wrap_plstart(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12848
plstripa
#define plstripa
Definition: plplot.h:843
_wrap_plgfci
SWIGINTERN PyObject * _wrap_plgfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7071
_wrap_plgzax_texinfo
static const char * _wrap_plgzax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10045
SWIG_global_name
#define SWIG_global_name
Definition: plplot_octaveOCTAVE_wrap.cxx:19
_wrap_plenv_texinfo
static const char * _wrap_plenv_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8846
swig_dycast_func
struct swig_type_info *(* swig_dycast_func)(void **)
Definition: plplot_octaveOCTAVE_wrap.cxx:460
_wrap_plrgbhls
SWIGINTERN PyObject * _wrap_plrgbhls(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10502
plstring3
#define plstring3
Definition: plplot.h:842
_wrap_plshade
SWIGINTERN PyObject * _wrap_plshade(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12157
octave_swig_type::decref
void decref()
Definition: plplot_octaveOCTAVE_wrap.cxx:1372
SWIG_NEWOBJ
#define SWIG_NEWOBJ
Definition: plplot_octaveOCTAVE_wrap.cxx:421
_wrap_plscmap1l_texinfo
static const char * _wrap_plscmap1l_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3891
plvpas
#define plvpas
Definition: plplot.h:859
_wrap_plsfnam
SWIGINTERN PyObject * _wrap_plsfnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11909
_wrap_plgdiplt
SWIGINTERN PyObject * _wrap_plgdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6977
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:1962
_wrap_delete_PLGraphicsIn
SWIGINTERN PyObject * _wrap_delete_PLGraphicsIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4919
octave_swig_type::load_ascii
virtual bool load_ascii(std::istream &is)
Definition: plplot_octaveOCTAVE_wrap.cxx:1743
_wrap_plw3d
SWIGINTERN PyObject * _wrap_plw3d(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14031
plsfont
#define plsfont
Definition: plplot.h:819
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:3141
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
_swigt__p_PLGraphicsIn
static swig_type_info _swigt__p_PLGraphicsIn
Definition: plplot_octaveOCTAVE_wrap.cxx:25027
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
_wrap_plsurf3dl_texinfo
static const char * _wrap_plsurf3dl_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5657
f2c
#define f2c(f, ff, nx, ny)
Definition: plplot_octaveOCTAVE_wrap.cxx:2925
SWIG_IsTmpObj
#define SWIG_IsTmpObj(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:429
_wrap_plfontld_texinfo
static const char * _wrap_plfontld_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6477
plpsty
#define plpsty
Definition: plplot.h:784
_wrap_plszax
SWIGINTERN PyObject * _wrap_plszax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13702
_wrap_plerry_texinfo
static const char * _wrap_plerry_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10598
_wrap_plstransform
SWIGINTERN PyObject * _wrap_plstransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12890
_wrap_plline3_texinfo
static const char * _wrap_plline3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6444
_wrap_plscmap1n_texinfo
static const char * _wrap_plscmap1n_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4227
SWIG_Error
SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg)
Definition: plplot_octaveOCTAVE_wrap.cxx:917
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:3013
_wrap_plvasp
SWIGINTERN PyObject * _wrap_plvasp(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13768
swig_octave_member
Definition: plplot_octaveOCTAVE_wrap.cxx:995
plgvpd
#define plgvpd
Definition: plplot.h:746
octave_swig_type::map_keys
virtual string_vector map_keys() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1727
_wrap_class_PLGraphicsIn
static swig_octave_class _wrap_class_PLGraphicsIn
Definition: plplot_octaveOCTAVE_wrap.cxx:16252
plpoin
#define plpoin
Definition: plplot.h:780
plgriddata
#define plgriddata
Definition: plplot.h:742
octave_swig_ref::is_object
virtual bool is_object() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1968
plgvpw
#define plgvpw
Definition: plplot.h:747
SWIG_AsVal_long
SWIGINTERN int SWIG_AsVal_long(const octave_value &ov, long *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:2765
_wrap_plerrx
SWIGINTERN PyObject * _wrap_plerrx(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6242
PLGraphicsIn::wX
PLFLT wX
Definition: plplot.h:443
SWIGRUNTIMEINLINE
#define SWIGRUNTIMEINLINE
Definition: plplot_octaveOCTAVE_wrap.cxx:312
PLGraphicsIn::subwindow
PLINT subwindow
Definition: plplot.h:439
_wrap_plschr
SWIGINTERN PyObject * _wrap_plschr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10571
_swigc__p_unsigned_int
static swig_cast_info _swigc__p_unsigned_int[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25057
_wrap_PLGraphicsIn_dY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4750
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:2953
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:2944
_wrap_plstar
SWIGINTERN PyObject * _wrap_plstar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12818
_wrap_plpoly3
SWIGINTERN PyObject * _wrap_plpoly3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10145
text
static int text
Definition: ps.c:77
SWIG_IndexError
#define SWIG_IndexError
Definition: plplot_octaveOCTAVE_wrap.cxx:855
_wrap_plgcolbg_texinfo
static const char * _wrap_plgcolbg_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10251
_wrap_PLGraphicsIn_type_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4305
SWIG_CAST_NEW_MEMORY
#define SWIG_CAST_NEW_MEMORY
Definition: plplot_octaveOCTAVE_wrap.cxx:322
_wrap_plrandd_texinfo
static const char * _wrap_plrandd_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5326
max
int max(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2492
_wrap_plimagefr
SWIGINTERN PyObject * _wrap_plimagefr(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15014
_wrap_plgcompression
SWIGINTERN PyObject * _wrap_plgcompression(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6860
_wrap_plspal1_texinfo
static const char * _wrap_plspal1_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5481
_wrap_plgcolbg
SWIGINTERN PyObject * _wrap_plgcolbg(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6766
SWIG_Octave_LinkGlobalValue
SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2391
_wrap_plclear
SWIGINTERN PyObject * _wrap_plclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5662
_wrap_plmtex_texinfo
static const char * _wrap_plmtex_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5207
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:3169
_wrap_plfont_texinfo
static const char * _wrap_plfont_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5743
swig_this_usage
static const char *const swig_this_usage
Definition: plplot_octaveOCTAVE_wrap.cxx:25470
labelfunc_octave
void labelfunc_octave(PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data)
Definition: plplot_octaveOCTAVE_wrap.cxx:2667
SWIG_AttributeError
#define SWIG_AttributeError
Definition: plplot_octaveOCTAVE_wrap.cxx:862
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:1788
_wrap_plline_texinfo
static const char * _wrap_plline_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7908
_wrap_plsstrm
SWIGINTERN PyObject * _wrap_plsstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12737
_wrap_plbop_texinfo
static const char * _wrap_plbop_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4367
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:2964
_wrap_plscol0
SWIGINTERN PyObject * _wrap_plscol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11281
_wrap_plssym
SWIGINTERN PyObject * _wrap_plssym(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12788
_wrap_plcolorbar_texinfo
static const char * _wrap_plcolorbar_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8228
plmkstrm
#define plmkstrm
Definition: plplot.h:772
PLGraphicsIn::pX
int pX
Definition: plplot.h:441
swig_octave_member::doc
const char * doc
Definition: plplot_octaveOCTAVE_wrap.cxx:1001
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:3234
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:3056
PLFLT
float PLFLT
Definition: plplot.h:163
octave_swig_type
Definition: plplot_octaveOCTAVE_wrap.cxx:1089
_wrap_plcalc_world
SWIGINTERN PyObject * _wrap_plcalc_world(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5602
plscol0
#define plscol0
Definition: plplot.h:800
plplotc.pltr2
def pltr2
Definition: plplotc.py:109
SWIG_UnpackDataName
SWIGRUNTIME const char * SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name)
Definition: plplot_octaveOCTAVE_wrap.cxx:835
swig_type_info
Definition: plplotluacLUA_wrap.c:328
_wrap_pltext_texinfo
static const char * _wrap_pltext_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9794
plxormod
#define plxormod
Definition: plplot.h:865
_wrap_plscolor
SWIGINTERN PyObject * _wrap_plscolor(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11473
_wrap_plxormod_texinfo
static const char * _wrap_plxormod_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7319
SWIG_SyntaxError
#define SWIG_SyntaxError
Definition: plplot_octaveOCTAVE_wrap.cxx:859
_wrap_plerrx_texinfo
static const char * _wrap_plerrx_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10442
plflush
#define plflush
Definition: plplot.h:719
plerrx
#define plerrx
Definition: plplot.h:714
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:2056
plgcol0a
#define plgcol0a
Definition: plplot.h:725
SWIG_IOError
#define SWIG_IOError
Definition: plplot_octaveOCTAVE_wrap.cxx:853
_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:25053
plgcolbga
#define plgcolbga
Definition: plplot.h:727
_wrap_plsdiplt_texinfo
static const char * _wrap_plsdiplt_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9441
_wrap_plfill_texinfo
static const char * _wrap_plfill_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5106
octave_swig_type::dispatch_unary_op
bool dispatch_unary_op(const std::string &symbol, octave_value &ret) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1210
_wrap_plpoly3_texinfo
static const char * _wrap_plpoly3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10323
_wrap_plscolor_texinfo
static const char * _wrap_plscolor_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6610
_wrap_plscol0a_texinfo
static const char * _wrap_plscol0a_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3628
SWIG_PackDataName
SWIGRUNTIME char * SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz)
Definition: plplot_octaveOCTAVE_wrap.cxx:820
octave_swig_packed::buf
std::vector< char > buf
Definition: plplot_octaveOCTAVE_wrap.cxx:2073
_wrap_plgspa
SWIGINTERN PyObject * _wrap_plgspa(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7406
_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:25031
_wrap_plsym_texinfo
static const char * _wrap_plsym_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9495
_wrap_plcpstrm
SWIGINTERN PyObject * _wrap_plcpstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6044
_wrap_plbin_texinfo
static const char * _wrap_plbin_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9880
octave_swig_type::empty_clone
octave_base_value * empty_clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1501
_wrap_pllegend
SWIGINTERN PyObject * _wrap_pllegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7943
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:1239
octave_swig_ref::map_keys
virtual string_vector map_keys() const
Definition: plplot_octaveOCTAVE_wrap.cxx:2001
SWIG_AddCast
#define SWIG_AddCast(r)
Definition: plplot_octaveOCTAVE_wrap.cxx:448
plgyax
#define plgyax
Definition: plplot.h:749
_wrap_PLGraphicsIn_subwindow_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_subwindow_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4513
plsesc
#define plsesc
Definition: plplot.h:814
_wrap_PLGraphicsIn_dY_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_dY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4780
_wrap_plsfci
SWIGINTERN PyObject * _wrap_plsfci(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11888
plenv
#define plenv
Definition: plplot.h:711
Alen
static PLINT Alen
Definition: plplot_octaveOCTAVE_wrap.cxx:2482
swigreg_unary_op
#define swigreg_unary_op(name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2226
octave_swig_type::swig_members_end
swig_member_const_iterator swig_members_end()
Definition: plplot_octaveOCTAVE_wrap.cxx:1429
_wrap_plsesc_texinfo
static const char * _wrap_plsesc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8775
octave_swig_ref::map_value
virtual Octave_map map_value() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1997
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:3049
octave_swig_ref::~octave_swig_ref
~octave_swig_ref()
Definition: plplot_octaveOCTAVE_wrap.cxx:1938
swig_cast_info::next
struct swig_cast_info * next
Definition: plplotluacLUA_wrap.c:341
_wrap_plparseopts_texinfo
static const char * _wrap_plparseopts_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6969
_wrap_plmaptex
SWIGINTERN PyObject * _wrap_plmaptex(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14556
octave_swig_packed::copy
bool copy(swig_type_info *outtype, void *ptr, size_t sz) const
Definition: plplot_octaveOCTAVE_wrap.cxx:2080
_wrap_plvect_texinfo
static const char * _wrap_plvect_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9368
_wrap_plw3d_texinfo
static const char * _wrap_plw3d_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5025
_wrap_plsori
SWIGINTERN PyObject * _wrap_plsori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12572
swig_type_info::owndata
int owndata
Definition: plplotluacLUA_wrap.c:334
_swigt__p_unsigned_int
static swig_type_info _swigt__p_unsigned_int
Definition: plplot_octaveOCTAVE_wrap.cxx:25035
_wrap_plot3dcl
SWIGINTERN PyObject * _wrap_plot3dcl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9443
_wrap_plglevel_texinfo
static const char * _wrap_plglevel_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9854
SWIG_op_prefix
#define SWIG_op_prefix
Definition: plplot_octaveOCTAVE_wrap.cxx:20
swig_octave_class::members
const swig_octave_member * members
Definition: plplot_octaveOCTAVE_wrap.cxx:1016
plgcmap1_range
#define plgcmap1_range
Definition: plplot.h:723
_wrap_plcol0
SWIGINTERN PyObject * _wrap_plcol0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5674
plcol0
#define plcol0
Definition: plplot.h:702
octave_swig_ref::scalar_value
virtual double scalar_value(bool frc_str_conv=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1977
SWIG_RuntimeError
#define SWIG_RuntimeError
Definition: plplot_octaveOCTAVE_wrap.cxx:854
SWIG_InstallOps
SWIGRUNTIME void SWIG_InstallOps(int tid)
Definition: plplot_octaveOCTAVE_wrap.cxx:2310
_wrap_pllsty
SWIGINTERN PyObject * _wrap_pllsty(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8899
plbox3
#define plbox3
Definition: plplot.h:698
_wrap_pllab
SWIGINTERN PyObject * _wrap_pllab(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7895
octave_swig_type::swig_this
long swig_this() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1377
SWIG_AsVal_char
SWIGINTERN int SWIG_AsVal_char(octave_value obj, char *val)
Definition: plplot_octaveOCTAVE_wrap.cxx:3429
_arraylen
static int _arraylen(const octave_value &o_obj)
Definition: plplot_octaveOCTAVE_wrap.cxx:2510
plcolorbar
#define plcolorbar
Definition: plplot.h:704
octave_swig_ref
Definition: plplot_octaveOCTAVE_wrap.cxx:1932
swig_cast_initial
static swig_cast_info * swig_cast_initial[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25059
octave_swig_type::module
swig_module_info * module
Definition: plplot_octaveOCTAVE_wrap.cxx:1097
swig_octave_member::name
const char * name
Definition: plplot_octaveOCTAVE_wrap.cxx:996
fill_func
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
Definition: plplot_octaveOCTAVE_wrap.cxx:2604
_wrap_plstart_texinfo
static const char * _wrap_plstart_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10722
PLGraphicsIn::state
unsigned int state
Definition: plplot.h:436
testppchar
void testppchar(PLINT nlegend, const PLINT *opt_array, const char **text)
Definition: plplot_octaveOCTAVE_wrap.cxx:2742
SWIG_fail
#define SWIG_fail
Definition: plplot_octaveOCTAVE_wrap.cxx:925
swig_octave_member::set_method
octave_func set_method
Definition: plplot_octaveOCTAVE_wrap.cxx:999
_wrap_plhlsrgb
SWIGINTERN PyObject * _wrap_plhlsrgb(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7766
plglevel
#define plglevel
Definition: plplot.h:738
octave_swig_packed::load_ascii
virtual bool load_ascii(std::istream &is)
Definition: plplot_octaveOCTAVE_wrap.cxx:2115
_wrap_plsurf3d_texinfo
static const char * _wrap_plsurf3d_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7653
_wrap_pllab_texinfo
static const char * _wrap_pllab_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4304
PLcGrid::xg
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:508
_wrap_plreplot
SWIGINTERN PyObject * _wrap_plreplot(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10490
SWIG_TypePrettyName
SWIGRUNTIME const char * SWIG_TypePrettyName(const swig_type_info *type)
Definition: plplot_octaveOCTAVE_wrap.cxx:627
_wrap_plgpage_texinfo
static const char * _wrap_plgpage_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9179
SWIG_ValueError
#define SWIG_ValueError
Definition: plplot_octaveOCTAVE_wrap.cxx:860
plpoin3
#define plpoin3
Definition: plplot.h:781
octave_swig_type::clone
octave_base_value * clone() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1493
swig_cast_info
struct swig_cast_info swig_cast_info
_wrap_plsmaj
SWIGINTERN PyObject * _wrap_plsmaj(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12426
swig_globals
static const struct swig_octave_member swig_globals[]
Definition: plplot_octaveOCTAVE_wrap.cxx:24805
_wrap_plwidth
SWIGINTERN PyObject * _wrap_plwidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:14142
octave_swig_type::load_members
void load_members(const swig_octave_class *c, member_map &out) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1173
_wrap_plsdiplz_texinfo
static const char * _wrap_plsdiplz_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9580
plscmap0n
#define plscmap0n
Definition: plplot.h:793
SWIG_InitializeModule
SWIGRUNTIME void SWIG_InitializeModule(void *clientdata)
Definition: plplot_octaveOCTAVE_wrap.cxx:25128
octave_swig_type::member_value_pair
std::pair< const swig_octave_member *, octave_value > member_value_pair
Definition: plplot_octaveOCTAVE_wrap.cxx:1103
plscolor
#define plscolor
Definition: plplot.h:804
plsvpa
#define plsvpa
Definition: plplot.h:850
octave_value_ref::octave_value_ref
octave_value_ref(const octave_value_list &_ovl, int _j)
Definition: plplot_octaveOCTAVE_wrap.cxx:2172
_wrap_plprec
SWIGINTERN PyObject * _wrap_plprec(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10243
_wrap_plsurf3dl
SWIGINTERN PyObject * _wrap_plsurf3dl(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9689
_wrap_plarc
SWIGINTERN PyObject * _wrap_plarc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5067
plpat
#define plpat
Definition: plplot.h:779
pl_setcontlabelformat
#define pl_setcontlabelformat
Definition: plplot.h:690
_wrap_PLGraphicsIn_button_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_button_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4431
plscmap1_range
#define plscmap1_range
Definition: plplot.h:799
SWIG_POINTER_DISOWN
#define SWIG_POINTER_DISOWN
Definition: plplot_octaveOCTAVE_wrap.cxx:321
_wrap_plcalc_world_texinfo
static const char * _wrap_plcalc_world_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8571
swig_cast_info::prev
struct swig_cast_info * prev
Definition: plplotluacLUA_wrap.c:342
octave_swig_ref::string_value
virtual std::string string_value(bool force=false) const
Definition: plplot_octaveOCTAVE_wrap.cxx:1974
_wrap_plcol1_texinfo
static const char * _wrap_plcol1_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6183
_wrap_plot3d_texinfo
static const char * _wrap_plot3d_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5878
plgcol0
#define plgcol0
Definition: plplot.h:724
_wrap_plslabelfunc_texinfo
static const char * _wrap_plslabelfunc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6854
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
_wrap_plshade_texinfo
static const char * _wrap_plshade_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8441
_wrap_plcolorbar
SWIGINTERN PyObject * _wrap_plcolorbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:8426
plreplot
#define plreplot
Definition: plplot.h:788
swig_module_info::cast_initial
swig_cast_info ** cast_initial
Definition: plplotluacLUA_wrap.c:353
_wrap_plgstrm
SWIGINTERN PyObject * _wrap_plgstrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7458
_wrap_plmeshc_texinfo
static const char * _wrap_plmeshc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7432
_wrap_plvect
SWIGINTERN PyObject * _wrap_plvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13789
_wrap_plmkstrm_texinfo
static const char * _wrap_plmkstrm_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9151
PLGraphicsIn::button
unsigned int button
Definition: plplot.h:438
swig_type_initial
static swig_type_info * swig_type_initial[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25037
SWIG_DEFUN
#define SWIG_DEFUN(cname, wname, doc)
Definition: plplot_octaveOCTAVE_wrap.cxx:871
_wrap_plptex3
SWIGINTERN PyObject * _wrap_plptex3(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10363
_wrap_plrgbhls_texinfo
static const char * _wrap_plrgbhls_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9715
_wrap_plpath_texinfo
static const char * _wrap_plpath_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:8811
_wrap_PLGraphicsIn_state_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_state_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4327
_wrap_plgcolbga_texinfo
static const char * _wrap_plgcolbga_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10412
octave_swig_type::always_static
bool always_static
Definition: plplot_octaveOCTAVE_wrap.cxx:1106
swig_unary_op
#define swig_unary_op(name)
Definition: plplot_octaveOCTAVE_wrap.cxx:2213
plscmap1l
#define plscmap1l
Definition: plplot.h:796
plmap
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
Swig::swig_value_deref
SWIGRUNTIME octave_swig_type * swig_value_deref(const octave_base_value &ov)
Definition: plplot_octaveOCTAVE_wrap.cxx:2203
_wrap_plgfnam_texinfo
static const char * _wrap_plgfnam_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3835
plprec
#define plprec
Definition: plplot.h:783
SWIG_DivisionByZero
#define SWIG_DivisionByZero
Definition: plplot_octaveOCTAVE_wrap.cxx:857
my_plTranslateCursor
static int my_plTranslateCursor(PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in)
Definition: plplot_octaveOCTAVE_wrap.cxx:2862
_wrap_plcpstrm_texinfo
static const char * _wrap_plcpstrm_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7246
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
plptex
#define plptex
Definition: plplot.h:785
_wrap_PLGraphicsIn_wY_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wY_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4854
SWIG_TypeNameComp
SWIGRUNTIME int SWIG_TypeNameComp(const char *f1, const char *l1, const char *f2, const char *l2)
Definition: plplot_octaveOCTAVE_wrap.cxx:500
_wrap_plmap_texinfo
static const char * _wrap_plmap_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6284
octave_swig_type::construct_type
const swig_type_info * construct_type
Definition: plplot_octaveOCTAVE_wrap.cxx:1099
_wrap_pllsty_texinfo
static const char * _wrap_pllsty_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9470
plline
#define plline
Definition: plplot.h:760
PLGraphicsIn::dY
PLFLT dY
Definition: plplot.h:442
SWIG_MemoryError
#define SWIG_MemoryError
Definition: plplot_octaveOCTAVE_wrap.cxx:863
_wrap_plscmap0a
SWIGINTERN PyObject * _wrap_plscmap0a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10671
SWIG_OCTAVE_PREREQ
#define SWIG_OCTAVE_PREREQ(major, minor, patch)
Definition: plplot_octaveOCTAVE_wrap.cxx:180
PLcGrid2::xg
PLFLT_NC_MATRIX xg
Definition: plplot.h:520
_wrap_pllegend_texinfo
static const char * _wrap_pllegend_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4006
_wrap_plptex3_texinfo
static const char * _wrap_plptex3_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10074
SWIG_TypeCast
SWIGRUNTIMEINLINE void * SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory)
Definition: plplot_octaveOCTAVE_wrap.cxx:596
_wrap_plgvpw
SWIGINTERN PyObject * _wrap_plgvpw(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7553
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:3088
SWIG_TypeDynamicCast
SWIGRUNTIME swig_type_info * SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
Definition: plplot_octaveOCTAVE_wrap.cxx:604
plgradient
#define plgradient
Definition: plplot.h:741
_wrap_plclear_texinfo
static const char * _wrap_plclear_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9022
_wrap_plaxes_texinfo
static const char * _wrap_plaxes_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10160
octave_value_ref::ovl
const octave_value_list & ovl
Definition: plplot_octaveOCTAVE_wrap.cxx:2169
_wrap_plsdiori_texinfo
static const char * _wrap_plsdiori_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7542
swig_module_info::type_initial
swig_type_info ** type_initial
Definition: plplotluacLUA_wrap.c:352
_wrap_plscmap0
SWIGINTERN PyObject * _wrap_plscmap0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10601
_wrap_plend_texinfo
static const char * _wrap_plend_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7630
_wrap_plhlsrgb_texinfo
static const char * _wrap_plhlsrgb_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10494
_wrap_plspal0
SWIGINTERN PyObject * _wrap_plspal0(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12659
_wrap_plscol0_texinfo
static const char * _wrap_plscol0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9081
_wrap_plmeshc
SWIGINTERN PyObject * _wrap_plmeshc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9003
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:1518
_wrap_pladv
SWIGINTERN PyObject * _wrap_pladv(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5046
pladv
#define pladv
Definition: plplot.h:692
swig_type_info::name
const char * name
Definition: plplotluacLUA_wrap.c:329
_wrap_plstripd
SWIGINTERN PyObject * _wrap_plstripd(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13391
_wrap_plsfam
SWIGINTERN PyObject * _wrap_plsfam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11849
octave_swig_type::is_defined
bool is_defined() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1505
_wrap_plgra
SWIGINTERN PyObject * _wrap_plgra(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7250
plvasp
#define plvasp
Definition: plplot.h:857
plrandd
#define plrandd
Definition: plplot.h:787
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:2040
_wrap_plmaptex_texinfo
static const char * _wrap_plmaptex_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6079
_wrap_plsxax
SWIGINTERN PyObject * _wrap_plsxax(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13584
plscmap0
#define plscmap0
Definition: plplot.h:791
_wrap_plssub
SWIGINTERN PyObject * _wrap_plssub(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:12758
_wrap_plssym_texinfo
static const char * _wrap_plssym_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10694
_dim
static int _dim(const octave_value &o_obj, int dim_idx)
Definition: plplot_octaveOCTAVE_wrap.cxx:2539
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
plgstrm
#define plgstrm
Definition: plplot.h:744
_wrap_plaxes
SWIGINTERN PyObject * _wrap_plaxes(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:5151
octave_swig_type::cpp_ptr
Definition: plplot_octaveOCTAVE_wrap.cxx:1090
swig_type_info
struct swig_type_info swig_type_info
octave_swig_type::member_deref
octave_value_list member_deref(member_value_pair *m, const octave_value_list &args)
Definition: plplot_octaveOCTAVE_wrap.cxx:1253
plsfci
#define plsfci
Definition: plplot.h:817
swig_PLGraphicsIn_members
static swig_octave_member swig_PLGraphicsIn_members[]
Definition: plplot_octaveOCTAVE_wrap.cxx:16235
PLGraphicsIn::pY
int pY
Definition: plplot.h:441
_wrap_plmapfill_texinfo
static const char * _wrap_plmapfill_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:10532
_wrap_plscmap1la_texinfo
static const char * _wrap_plscmap1la_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7117
_wrap_pl_setcontlabelparam_texinfo
static const char * _wrap_pl_setcontlabelparam_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7812
_wrap_plgdiori
SWIGINTERN PyObject * _wrap_plgdiori(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6955
swig_type_info::clientdata
void * clientdata
Definition: plplotluacLUA_wrap.c:333
PLGraphicsIn::wY
PLFLT wY
Definition: plplot.h:443
octave_swig_ref::DECLARE_OCTAVE_ALLOCATOR
DECLARE_OCTAVE_ALLOCATOR
Definition: plplot_octaveOCTAVE_wrap.cxx:2062
_wrap_pl_setcontlabelparam
SWIGINTERN PyObject * _wrap_pl_setcontlabelparam(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4998
_wrap_plfamadv_texinfo
static const char * _wrap_plfamadv_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:9613
swig_module_info
Definition: plplotluacLUA_wrap.c:348
PLGraphicsIn::string
char string[PL_MAXKEY]
Definition: plplot.h:440
_wrap_plgver
SWIGINTERN PyObject * _wrap_plgver(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7480
SWIG_PackData
SWIGRUNTIME char * SWIG_PackData(char *c, void *ptr, size_t sz)
Definition: plplot_octaveOCTAVE_wrap.cxx:752
plmtex
#define plmtex
Definition: plplot.h:773
_wrap_plgxax_texinfo
static const char * _wrap_plgxax_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5972
plrgbhls
#define plrgbhls
Definition: plplot.h:789
plsurf3d
#define plsurf3d
Definition: plplot.h:847
_wrap_plspause_texinfo
static const char * _wrap_plspause_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3983
plplotc.pltr1
def pltr1
Definition: plplotc.py:105
plgra
#define plgra
Definition: plplot.h:740
_wrap_plmapstring_texinfo
static const char * _wrap_plmapstring_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4858
_wrap_plscmap1n
SWIGINTERN PyObject * _wrap_plscmap1n(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11198
_wrap_plctime_texinfo
static const char * _wrap_plctime_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6233
_wrap_plsdiplz
SWIGINTERN PyObject * _wrap_plsdiplz(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11722
_wrap_PLGraphicsIn_keysym_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_keysym_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4379
string
_wrap_plClearOpts
SWIGINTERN PyObject * _wrap_plClearOpts(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:15174
plsdimap
#define plsdimap
Definition: plplot.h:808
SWIG_TypeCheckStruct
SWIGRUNTIME swig_cast_info * SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty)
Definition: plplot_octaveOCTAVE_wrap.cxx:569
_wrap_plgriddata
SWIGINTERN PyObject * _wrap_plgriddata(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:7262
_wrap_plsvpa_texinfo
static const char * _wrap_plsvpa_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:3446
swig_octave_class::base_names
const char ** base_names
Definition: plplot_octaveOCTAVE_wrap.cxx:1017
_wrap_plend
SWIGINTERN PyObject * _wrap_plend(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:6074
_wrap_PLGraphicsIn_string_set
SWIGINTERN PyObject * _wrap_PLGraphicsIn_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4535
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:1605
_swigc__p_PLGraphicsIn
static swig_cast_info _swigc__p_PLGraphicsIn[]
Definition: plplot_octaveOCTAVE_wrap.cxx:25049
_wrap_plpat
SWIGINTERN PyObject * _wrap_plpat(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:9903
_wrap_plvpas_texinfo
static const char * _wrap_plvpas_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:6815
f2eval_func
PLFLT(* f2eval_func)(PLINT, PLINT, PLPointer)
Definition: plplot_octaveOCTAVE_wrap.cxx:2608
plot3d
#define plot3d
Definition: plplot.h:775
_wrap_plstripc
SWIGINTERN PyObject * _wrap_plstripc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13127
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:1201
_wrap_plsvect
SWIGINTERN PyObject * _wrap_plsvect(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:13461
_wrap_plsesc
SWIGINTERN PyObject * _wrap_plsesc(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11791
_wrap_plsdiplt
SWIGINTERN PyObject * _wrap_plsdiplt(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11674
SWIG_From_int
SWIGINTERNINLINE octave_value SWIG_From_int(int value)
Definition: plplot_octaveOCTAVE_wrap.cxx:2849
_wrap_plconfigtime_texinfo
static const char * _wrap_plconfigtime_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4527
_wrap_PLGraphicsIn_wX_get
SWIGINTERN PyObject * _wrap_PLGraphicsIn_wX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:4832
plslabelfunc
#define plslabelfunc
Definition: plplot.h:825
PLcGrid::nx
PLINT nx
Definition: plplot.h:509
SWIG_strnlen
SWIGINTERN size_t SWIG_strnlen(const char *s, size_t maxlen)
Definition: plplot_octaveOCTAVE_wrap.cxx:3419
SWIG_From_unsigned_SS_long
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long(unsigned long value)
Definition: plplot_octaveOCTAVE_wrap.cxx:3360
_wrap_plot3dc_texinfo
static const char * _wrap_plot3dc_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:5138
octave_swig_type::~octave_swig_type
~octave_swig_type()
Definition: plplot_octaveOCTAVE_wrap.cxx:1294
octave_swig_type::cpp_ptr::ptr
void * ptr
Definition: plplot_octaveOCTAVE_wrap.cxx:1091
_wrap_plscmap1a
SWIGINTERN PyObject * _wrap_plscmap1a(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:10852
DEFINE_OCTAVE_ALLOCATOR
DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref)
__swig_atexit__
void __swig_atexit__(void)
Definition: plplot_octaveOCTAVE_wrap.cxx:25512
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:1279
_wrap_plscmap0_texinfo
static const char * _wrap_plscmap0_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:4393
SWIG_NewPointerObj
#define SWIG_NewPointerObj(ptr, type, flags)
Definition: plplot_octaveOCTAVE_wrap.cxx:931
octave_swig_type::types
std::vector< type_ptr_pair > types
Definition: plplot_octaveOCTAVE_wrap.cxx:1100
_wrap_plscmap1la
SWIGINTERN PyObject * _wrap_plscmap1la(PyObject *SWIGUNUSEDPARM(self), PyObject *args)
Definition: plplotcPYTHON_wrap.c:11060
octave_swig_ref::is_defined
bool is_defined() const
Definition: plplot_octaveOCTAVE_wrap.cxx:1953
SWIG_TypeCmp
SWIGRUNTIME int SWIG_TypeCmp(const char *nb, const char *tb)
Definition: plplot_octaveOCTAVE_wrap.cxx:515
_wrap_plhist_texinfo
static const char * _wrap_plhist_texinfo
Definition: plplot_octaveOCTAVE_wrap.cxx:7577
PLGraphicsIn
Definition: plplot.h:433
SWIG_From_unsigned_SS_int
SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_int(unsigned int value)
Definition: plplot_octaveOCTAVE_wrap.cxx:3367
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:2935