PLplot: plplot_octaveOCTAVE_wrap.cxx Source File

PLplot 5.10.0

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
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 2.0.7
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 #define SWIGOCTAVE
12 #define SWIG_name_d "plplot_octave"
13 #define SWIG_name plplot_octave
14
15 #define SWIG_global_name "cvar"
16 #define SWIG_op_prefix "op_"
17
18
19 #ifdef __cplusplus
20 /* SwigValueWrapper is described in swig.swg */
21 template<typename T> class SwigValueWrapper {
22 struct SwigMovePointer {
23 T *ptr;
24 SwigMovePointer(T *p) : ptr(p) { }
25 ~SwigMovePointer() { delete ptr; }
26 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
27 } pointer;
28 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
29 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
30 public:
31 SwigValueWrapper() : pointer(0) { }
32 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
33 operator T&() const { return *pointer.ptr; }
34 T *operator&() { return pointer.ptr; }
35 };
36
37 template <typename T> T SwigValueInit() {
38 return T();
39 }
40 #endif
41
42 /* -----------------------------------------------------------------------------
43 * This section contains generic SWIG labels for method/variable
44 * declarations/attributes, and other compiler dependent labels.
45 * ----------------------------------------------------------------------------- */
46
47 /* template workaround for compilers that cannot correctly implement the C++ standard */
48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
50 # define SWIGTEMPLATEDISAMBIGUATOR template
51 # elif defined(__HP_aCC)
52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
54 # define SWIGTEMPLATEDISAMBIGUATOR template
55 # else
56 # define SWIGTEMPLATEDISAMBIGUATOR
57 # endif
58 #endif
59
60 /* inline attribute */
61 #ifndef SWIGINLINE
62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
63 # define SWIGINLINE inline
64 # else
65 # define SWIGINLINE
66 # endif
67 #endif
68
69 /* attribute recognised by some compilers to avoid 'unused' warnings */
70 #ifndef SWIGUNUSED
71 # if defined(__GNUC__)
72 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
73 # define SWIGUNUSED __attribute__ ((__unused__))
74 # else
75 # define SWIGUNUSED
76 # endif
77 # elif defined(__ICC)
78 # define SWIGUNUSED __attribute__ ((__unused__))
79 # else
80 # define SWIGUNUSED
81 # endif
82 #endif
83
84 #ifndef SWIG_MSC_UNSUPPRESS_4505
85 # if defined(_MSC_VER)
86 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
87 # endif
88 #endif
89
90 #ifndef SWIGUNUSEDPARM
91 # ifdef __cplusplus
92 # define SWIGUNUSEDPARM(p)
93 # else
94 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
95 # endif
96 #endif
97
98 /* internal SWIG method */
99 #ifndef SWIGINTERN
100 # define SWIGINTERN static SWIGUNUSED
101 #endif
102
103 /* internal inline SWIG method */
104 #ifndef SWIGINTERNINLINE
105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
106 #endif
107
108 /* exporting methods */
109 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
110 # ifndef GCC_HASCLASSVISIBILITY
111 # define GCC_HASCLASSVISIBILITY
112 # endif
113 #endif
114
115 #ifndef SWIGEXPORT
116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
117 # if defined(STATIC_LINKED)
118 # define SWIGEXPORT
119 # else
120 # define SWIGEXPORT __declspec(dllexport)
121 # endif
122 # else
123 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
124 # define SWIGEXPORT __attribute__ ((visibility("default")))
125 # else
126 # define SWIGEXPORT
127 # endif
128 # endif
129 #endif
130
131 /* calling conventions for Windows */
132 #ifndef SWIGSTDCALL
133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
134 # define SWIGSTDCALL __stdcall
135 # else
136 # define SWIGSTDCALL
137 # endif
138 #endif
139
140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
142 # define _CRT_SECURE_NO_DEPRECATE
143 #endif
144
145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
147 # define _SCL_SECURE_NO_DEPRECATE
148 #endif
149
150
151
152 #include <iostream>
153 #include <octave/oct.h>
154 #include <octave/Cell.h>
155 #include <octave/dynamic-ld.h>
156 #include <octave/oct-env.h>
157 #include <octave/oct-map.h>
158 #include <octave/ov-fcn-handle.h>
159 #include <octave/parse.h>
160 #include <octave/toplev.h>
161 #include <octave/unwind-prot.h>
162
163 /* -----------------------------------------------------------------------------
164 * swigrun.swg
165 *
166 * This file contains generic C API SWIG runtime support for pointer
167 * type checking.
168 * ----------------------------------------------------------------------------- */
169
170 /* This should only be incremented when either the layout of swig_type_info changes,
171 or for whatever reason, the runtime changes incompatibly */
172 #define SWIG_RUNTIME_VERSION "4"
173
174 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
175 #ifdef SWIG_TYPE_TABLE
176 # define SWIG_QUOTE_STRING(x) #x
177 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
178 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
179 #else
180 # define SWIG_TYPE_TABLE_NAME
181 #endif
182
183 /*
184 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
185 creating a static or dynamic library from the SWIG runtime code.
186 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
187
188 But only do this if strictly necessary, ie, if you have problems
189 with your compiler or suchlike.
190 */
191
192 #ifndef SWIGRUNTIME
193 # define SWIGRUNTIME SWIGINTERN
194 #endif
195
196 #ifndef SWIGRUNTIMEINLINE
197 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
198 #endif
199
200 /* Generic buffer size */
201 #ifndef SWIG_BUFFER_SIZE
202 # define SWIG_BUFFER_SIZE 1024
203 #endif
204
205 /* Flags for pointer conversions */
206 #define SWIG_POINTER_DISOWN 0x1
207 #define SWIG_CAST_NEW_MEMORY 0x2
208
209 /* Flags for new pointer objects */
210 #define SWIG_POINTER_OWN 0x1
211
212
213 /*
214 Flags/methods for returning states.
215
216 The SWIG conversion methods, as ConvertPtr, return an integer
217 that tells if the conversion was successful or not. And if not,
218 an error code can be returned (see swigerrors.swg for the codes).
219
220 Use the following macros/flags to set or process the returning
221 states.
222
223 In old versions of SWIG, code such as the following was usually written:
224
225 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
226 // success code
227 } else {
228 //fail code
229 }
230
231 Now you can be more explicit:
232
233 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
234 if (SWIG_IsOK(res)) {
235 // success code
236 } else {
237 // fail code
238 }
239
240 which is the same really, but now you can also do
241
242 Type *ptr;
243 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
244 if (SWIG_IsOK(res)) {
245 // success code
246 if (SWIG_IsNewObj(res) {
247 ...
248 delete *ptr;
249 } else {
250 ...
251 }
252 } else {
253 // fail code
254 }
255
256 I.e., now SWIG_ConvertPtr can return new objects and you can
257 identify the case and take care of the deallocation. Of course that
258 also requires SWIG_ConvertPtr to return new result values, such as
259
260 int SWIG_ConvertPtr(obj, ptr,...) {
261 if (<obj is ok>) {
262 if (<need new object>) {
263 *ptr = <ptr to new allocated object>;
264 return SWIG_NEWOBJ;
265 } else {
266 *ptr = <ptr to old object>;
267 return SWIG_OLDOBJ;
268 }
269 } else {
270 return SWIG_BADOBJ;
271 }
272 }
273
274 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
275 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
276 SWIG errors code.
277
278 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
279 allows to return the 'cast rank', for example, if you have this
280
281 int food(double)
282 int fooi(int);
283
284 and you call
285
286 food(1) // cast rank '1' (1 -> 1.0)
287 fooi(1) // cast rank '0'
288
289 just use the SWIG_AddCast()/SWIG_CheckState()
290 */
291
292 #define SWIG_OK (0)
293 #define SWIG_ERROR (-1)
294 #define SWIG_IsOK(r) (r >= 0)
295 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
296
297 /* The CastRankLimit says how many bits are used for the cast rank */
298 #define SWIG_CASTRANKLIMIT (1 << 8)
299 /* The NewMask denotes the object was created (using new/malloc) */
300 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
301 /* The TmpMask is for in/out typemaps that use temporal objects */
302 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
303 /* Simple returning values */
304 #define SWIG_BADOBJ (SWIG_ERROR)
305 #define SWIG_OLDOBJ (SWIG_OK)
306 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
307 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
308 /* Check, add and del mask methods */
309 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
310 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
311 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
312 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
313 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
314 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
315
316 /* Cast-Rank Mode */
317 #if defined(SWIG_CASTRANK_MODE)
318 # ifndef SWIG_TypeRank
319 # define SWIG_TypeRank unsigned long
320 # endif
321 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
322 # define SWIG_MAXCASTRANK (2)
323 # endif
324 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
325 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
326 SWIGINTERNINLINE int SWIG_AddCast(int r) {
327 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
328 }
329 SWIGINTERNINLINE int SWIG_CheckState(int r) {
330 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
331 }
332 #else /* no cast-rank mode */
333 # define SWIG_AddCast
334 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
335 #endif
336
337
338 #include <string.h>
339
340 #ifdef __cplusplus
341 extern "C" {
342 #endif
343
344 typedef void *(*swig_converter_func)(void *, int *);
345 typedef struct swig_type_info *(*swig_dycast_func)(void **);
346
347 /* Structure to store information on one type */
348 typedef struct swig_type_info {
349 const char *name; /* mangled name of this type */
350 const char *str; /* human readable name of this type */
351 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
352 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
353 void *clientdata; /* language specific type data */
354 int owndata; /* flag if the structure owns the clientdata */
355 } swig_type_info;
356
357 /* Structure to store a type and conversion function used for casting */
358 typedef struct swig_cast_info {
359 swig_type_info *type; /* pointer to type that is equivalent to this type */
360 swig_converter_func converter; /* function to cast the void pointers */
361 struct swig_cast_info *next; /* pointer to next cast in linked list */
362 struct swig_cast_info *prev; /* pointer to the previous cast */
363 } swig_cast_info;
364
365 /* Structure used to store module information
366 * Each module generates one structure like this, and the runtime collects
367 * all of these structures and stores them in a circularly linked list.*/
368 typedef struct swig_module_info {
369 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
370 size_t size; /* Number of types in this module */
371 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
372 swig_type_info **type_initial; /* Array of initially generated type structures */
373 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
374 void *clientdata; /* Language specific module data */
375 } swig_module_info;
376
377 /*
378 Compare two type names skipping the space characters, therefore
379 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
380
381 Return 0 when the two name types are equivalent, as in
382 strncmp, but skipping ' '.
383 */
384 SWIGRUNTIME int
385 SWIG_TypeNameComp(const char *f1, const char *l1,
386 const char *f2, const char *l2) {
387 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
388 while ((*f1 == ' ') && (f1 != l1)) ++f1;
389 while ((*f2 == ' ') && (f2 != l2)) ++f2;
390 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
391 }
392 return (int)((l1 - f1) - (l2 - f2));
393 }
394
395 /*
396 Check type equivalence in a name list like <name1>|<name2>|...
397 Return 0 if not equal, 1 if equal
398 */
399 SWIGRUNTIME int
400 SWIG_TypeEquiv(const char *nb, const char *tb) {
401 int equiv = 0;
402 const char* te = tb + strlen(tb);
403 const char* ne = nb;
404 while (!equiv && *ne) {
405 for (nb = ne; *ne; ++ne) {
406 if (*ne == '|') break;
407 }
408 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
409 if (*ne) ++ne;
410 }
411 return equiv;
412 }
413
414 /*
415 Check type equivalence in a name list like <name1>|<name2>|...
416 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
417 */
418 SWIGRUNTIME int
419 SWIG_TypeCompare(const char *nb, const char *tb) {
420 int equiv = 0;
421 const char* te = tb + strlen(tb);
422 const char* ne = nb;
423 while (!equiv && *ne) {
424 for (nb = ne; *ne; ++ne) {
425 if (*ne == '|') break;
426 }
427 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
428 if (*ne) ++ne;
429 }
430 return equiv;
431 }
432
433
434 /*
435 Check the typename
436 */
437 SWIGRUNTIME swig_cast_info *
438 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
439 if (ty) {
440 swig_cast_info *iter = ty->cast;
441 while (iter) {
442 if (strcmp(iter->type->name, c) == 0) {
443 if (iter == ty->cast)
444 return iter;
445 /* Move iter to the top of the linked list */
446 iter->prev->next = iter->next;
447 if (iter->next)
448 iter->next->prev = iter->prev;
449 iter->next = ty->cast;
450 iter->prev = 0;
451 if (ty->cast) ty->cast->prev = iter;
452 ty->cast = iter;
453 return iter;
454 }
455 iter = iter->next;
456 }
457 }
458 return 0;
459 }
460
461 /*
462 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
463 */
464 SWIGRUNTIME swig_cast_info *
465 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
466 if (ty) {
467 swig_cast_info *iter = ty->cast;
468 while (iter) {
469 if (iter->type == from) {
470 if (iter == ty->cast)
471 return iter;
472 /* Move iter to the top of the linked list */
473 iter->prev->next = iter->next;
474 if (iter->next)
475 iter->next->prev = iter->prev;
476 iter->next = ty->cast;
477 iter->prev = 0;
478 if (ty->cast) ty->cast->prev = iter;
479 ty->cast = iter;
480 return iter;
481 }
482 iter = iter->next;
483 }
484 }
485 return 0;
486 }
487
488 /*
489 Cast a pointer up an inheritance hierarchy
490 */
491 SWIGRUNTIMEINLINE void *
492 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
493 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
494 }
495
496 /*
497 Dynamic pointer casting. Down an inheritance hierarchy
498 */
499 SWIGRUNTIME swig_type_info *
500 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
501 swig_type_info *lastty = ty;
502 if (!ty || !ty->dcast) return ty;
503 while (ty && (ty->dcast)) {
504 ty = (*ty->dcast)(ptr);
505 if (ty) lastty = ty;
506 }
507 return lastty;
508 }
509
510 /*
511 Return the name associated with this type
512 */
513 SWIGRUNTIMEINLINE const char *
514 SWIG_TypeName(const swig_type_info *ty) {
515 return ty->name;
516 }
517
518 /*
519 Return the pretty name associated with this type,
520 that is an unmangled type name in a form presentable to the user.
521 */
522 SWIGRUNTIME const char *
523 SWIG_TypePrettyName(const swig_type_info *type) {
524 /* The "str" field contains the equivalent pretty names of the
525 type, separated by vertical-bar characters. We choose
526 to print the last name, as it is often (?) the most
527 specific. */
528 if (!type) return NULL;
529 if (type->str != NULL) {
530 const char *last_name = type->str;
531 const char *s;
532 for (s = type->str; *s; s++)
533 if (*s == '|') last_name = s+1;
534 return last_name;
535 }
536 else
537 return type->name;
538 }
539
540 /*
541 Set the clientdata field for a type
542 */
543 SWIGRUNTIME void
544 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
545 swig_cast_info *cast = ti->cast;
546 /* if (ti->clientdata == clientdata) return; */
547 ti->clientdata = clientdata;
548
549 while (cast) {
550 if (!cast->converter) {
551 swig_type_info *tc = cast->type;
552 if (!tc->clientdata) {
553 SWIG_TypeClientData(tc, clientdata);
554 }
555 }
556 cast = cast->next;
557 }
558 }
559 SWIGRUNTIME void
560 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
561 SWIG_TypeClientData(ti, clientdata);
562 ti->owndata = 1;
563 }
564
565 /*
566 Search for a swig_type_info structure only by mangled name
567 Search is a O(log #types)
568
569 We start searching at module start, and finish searching when start == end.
570 Note: if start == end at the beginning of the function, we go all the way around
571 the circular list.
572 */
573 SWIGRUNTIME swig_type_info *
574 SWIG_MangledTypeQueryModule(swig_module_info *start,
575 swig_module_info *end,
576 const char *name) {
577 swig_module_info *iter = start;
578 do {
579 if (iter->size) {
580 register size_t l = 0;
581 register size_t r = iter->size - 1;
582 do {
583 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
584 register size_t i = (l + r) >> 1;
585 const char *iname = iter->types[i]->name;
586 if (iname) {
587 register int compare = strcmp(name, iname);
588 if (compare == 0) {
589 return iter->types[i];
590 } else if (compare < 0) {
591 if (i) {
592 r = i - 1;
593 } else {
594 break;
595 }
596 } else if (compare > 0) {
597 l = i + 1;
598 }
599 } else {
600 break; /* should never happen */
601 }
602 } while (l <= r);
603 }
604 iter = iter->next;
605 } while (iter != end);
606 return 0;
607 }
608
609 /*
610 Search for a swig_type_info structure for either a mangled name or a human readable name.
611 It first searches the mangled names of the types, which is a O(log #types)
612 If a type is not found it then searches the human readable names, which is O(#types).
613
614 We start searching at module start, and finish searching when start == end.
615 Note: if start == end at the beginning of the function, we go all the way around
616 the circular list.
617 */
618 SWIGRUNTIME swig_type_info *
619 SWIG_TypeQueryModule(swig_module_info *start,
620 swig_module_info *end,
621 const char *name) {
622 /* STEP 1: Search the name field using binary search */
623 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
624 if (ret) {
625 return ret;
626 } else {
627 /* STEP 2: If the type hasn't been found, do a complete search
628 of the str field (the human readable name) */
629 swig_module_info *iter = start;
630 do {
631 register size_t i = 0;
632 for (; i < iter->size; ++i) {
633 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
634 return iter->types[i];
635 }
636 iter = iter->next;
637 } while (iter != end);
638 }
639
640 /* neither found a match */
641 return 0;
642 }
643
644 /*
645 Pack binary data into a string
646 */
647 SWIGRUNTIME char *
648 SWIG_PackData(char *c, void *ptr, size_t sz) {
649 static const char hex[17] = "0123456789abcdef";
650 register const unsigned char *u = (unsigned char *) ptr;
651 register const unsigned char *eu = u + sz;
652 for (; u != eu; ++u) {
653 register unsigned char uu = *u;
654 *(c++) = hex[(uu & 0xf0) >> 4];
655 *(c++) = hex[uu & 0xf];
656 }
657 return c;
658 }
659
660 /*
661 Unpack binary data from a string
662 */
663 SWIGRUNTIME const char *
664 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
665 register unsigned char *u = (unsigned char *) ptr;
666 register const unsigned char *eu = u + sz;
667 for (; u != eu; ++u) {
668 register char d = *(c++);
669 register unsigned char uu;
670 if ((d >= '0') && (d <= '9'))
671 uu = ((d - '0') << 4);
672 else if ((d >= 'a') && (d <= 'f'))
673 uu = ((d - ('a'-10)) << 4);
674 else
675 return (char *) 0;
676 d = *(c++);
677 if ((d >= '0') && (d <= '9'))
678 uu |= (d - '0');
679 else if ((d >= 'a') && (d <= 'f'))
680 uu |= (d - ('a'-10));
681 else
682 return (char *) 0;
683 *u = uu;
684 }
685 return c;
686 }
687
688 /*
689 Pack 'void *' into a string buffer.
690 */
691 SWIGRUNTIME char *
692 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
693 char *r = buff;
694 if ((2*sizeof(void *) + 2) > bsz) return 0;
695 *(r++) = '_';
696 r = SWIG_PackData(r,&ptr,sizeof(void *));
697 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
698 strcpy(r,name);
699 return buff;
700 }
701
702 SWIGRUNTIME const char *
703 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
704 if (*c != '_') {
705 if (strcmp(c,"NULL") == 0) {
706 *ptr = (void *) 0;
707 return name;
708 } else {
709 return 0;
710 }
711 }
712 return SWIG_UnpackData(++c,ptr,sizeof(void *));
713 }
714
715 SWIGRUNTIME char *
716 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
717 char *r = buff;
718 size_t lname = (name ? strlen(name) : 0);
719 if ((2*sz + 2 + lname) > bsz) return 0;
720 *(r++) = '_';
721 r = SWIG_PackData(r,ptr,sz);
722 if (lname) {
723 strncpy(r,name,lname+1);
724 } else {
725 *r = 0;
726 }
727 return buff;
728 }
729
730 SWIGRUNTIME const char *
731 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
732 if (*c != '_') {
733 if (strcmp(c,"NULL") == 0) {
734 memset(ptr,0,sz);
735 return name;
736 } else {
737 return 0;
738 }
739 }
740 return SWIG_UnpackData(++c,ptr,sz);
741 }
742
743 #ifdef __cplusplus
744 }
745 #endif
746
747 /* Errors in SWIG */
748 #define SWIG_UnknownError -1
749 #define SWIG_IOError -2
750 #define SWIG_RuntimeError -3
751 #define SWIG_IndexError -4
752 #define SWIG_TypeError -5
753 #define SWIG_DivisionByZero -6
754 #define SWIG_OverflowError -7
755 #define SWIG_SyntaxError -8
756 #define SWIG_ValueError -9
757 #define SWIG_SystemError -10
758 #define SWIG_AttributeError -11
759 #define SWIG_MemoryError -12
760 #define SWIG_NullReferenceError -13
761
762
763
764
765 #include <octave/version.h>
766 #ifndef OCTAVE_API_VERSION_NUMBER
767
768 // Hack to distinguish between Octave 3.2 and earlier versions before OCTAVE_API_VERSION_NUMBER existed
769 #define ComplexLU __ignore
770 #include <octave/CmplxLU.h>
771 #undef ComplexLU
772 #ifdef octave_Complex_LU_h
773 # define OCTAVE_API_VERSION_NUMBER 36
774 #else
775 # define OCTAVE_API_VERSION_NUMBER 37
776 #endif
777
778 #endif
779
780 #if OCTAVE_API_VERSION_NUMBER < 37
781 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, FS ## cname, args, nargout, doc)
782 #else
783 #define SWIG_DEFUN(cname, wname, doc) DEFUNX_DLD(#cname, wname, G ## cname, args, nargout, doc)
784 #endif
785
786 SWIGRUNTIME bool SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
787 if (num_args > max_args && !varargs)
788 error("function %s takes at most %i arguments", func_name, max_args);
789 else if (num_args < min_args)
790 error("function %s requires at least %i arguments", func_name, min_args);
791 else
792 return true;
793 return false;
794 }
795
796 SWIGRUNTIME octave_value_list *SWIG_Octave_AppendOutput(octave_value_list *ovl, const octave_value &ov) {
797 ovl->append(ov);
798 return ovl;
799 }
800
801 SWIGRUNTIME octave_value SWIG_ErrorType(int code) {
802 switch (code) {
803 case SWIG_MemoryError:
804 return "SWIG_MemoryError";
805 case SWIG_IOError:
806 return "SWIG_IOError";
807 case SWIG_RuntimeError:
808 return "SWIG_RuntimeError";
809 case SWIG_IndexError:
810 return "SWIG_IndexError";
811 case SWIG_TypeError:
812 return "SWIG_TypeError";
813 case SWIG_DivisionByZero:
814 return "SWIG_DivisionByZero";
815 case SWIG_OverflowError:
816 return "SWIG_OverflowError";
817 case SWIG_SyntaxError:
818 return "SWIG_SyntaxError";
819 case SWIG_ValueError:
820 return "SWIG_ValueError";
821 case SWIG_SystemError:
822 return "SWIG_SystemError";
823 case SWIG_AttributeError:
824 return "SWIG_AttributeError";
825 }
826 return "SWIG unknown error";
827 }
828
829 SWIGRUNTIME octave_value SWIG_Error(int code, const char *msg) {
830 octave_value type(SWIG_ErrorType(code));
831 std::string r = msg;
832 r += " (" + type.string_value() + ")";
833 error(r.c_str());
834 return octave_value(r);
835 }
836
837 #define SWIG_fail goto fail
838
839 #define SWIG_Octave_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
840 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
841 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Octave_ConvertPtrAndOwn(obj, pptr, type, flags, own)
842 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Octave_ConvertPtr(obj, pptr, type, flags)
843 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Octave_NewPointerObj(ptr, type, flags)
844 #define swig_owntype int
845
846 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
847 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
848
849 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
850 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
851
852 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Octave_ConvertPacked(obj, ptr, sz, ty)
853 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Octave_NewPackedObj(ptr, sz, type)
854
855 #define SWIG_GetModule(clientdata) SWIG_Octave_GetModule(clientdata)
856 #define SWIG_SetModule(clientdata, pointer) SWIG_Octave_SetModule(clientdata,pointer);
857 #define SWIG_MODULE_CLIENTDATA_TYPE void*
858
859 #define Octave_Error_Occurred() 0
860 #define SWIG_Octave_AddErrorMsg(msg) {;}
861
862 SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata);
863 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer);
864
865 // For backward compatibility only
866 #define SWIG_POINTER_EXCEPTION 0
867 #define SWIG_arg_fail(arg) 0
868
869 // Runtime API implementation
870
871 #include <map>
872 #include <vector>
873 #include <string>
874
875 typedef octave_value_list(*octave_func) (const octave_value_list &, int);
876 class octave_swig_type;
877
878 namespace Swig {
879
880 #ifdef SWIG_DIRECTORS
881
882 class Director;
883
884 typedef std::map < void *, Director * > rtdir_map;
885 SWIGINTERN rtdir_map* get_rtdir_map();
886 SWIGINTERNINLINE void set_rtdir(void *vptr, Director *d);
887 SWIGINTERNINLINE void erase_rtdir(void *vptr);
888 SWIGINTERNINLINE Director *get_rtdir(void *vptr);
889
890 SWIGRUNTIME void swig_director_destroyed(octave_swig_type *self, Director *d);
891 SWIGRUNTIME octave_swig_type *swig_director_get_self(Director *d);
892 SWIGRUNTIME void swig_director_set_self(Director *d, octave_swig_type *self);
893
894 #endif
895
896 SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost);
897 SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov);
898 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov);
899 }
900
901 #ifdef SWIG_DIRECTORS
902 SWIGRUNTIME void swig_acquire_ownership(void *vptr);
903 SWIGRUNTIME void swig_acquire_ownership_array(void *vptr);
904 SWIGRUNTIME void swig_acquire_ownership_obj(void *vptr, int own);
905 #endif
906
907 struct swig_octave_member {
908 const char *name;
909 octave_func method;
910 octave_func get_method;
911 octave_func set_method;
912 int flags; // 1 static, 2 global
913 const char *doc;
914 bool is_static() const {
915 return flags &1;
916 } bool is_global() const {
917 return flags &2;
918 }
919 };
920
921 struct swig_octave_class {
922 const char *name;
923 swig_type_info **type;
924 int director;
925 octave_func constructor;
926 const char *constructor_doc;
927 octave_func destructor;
928 const swig_octave_member *members;
929 const char **base_names;
930 const swig_type_info **base;
931 };
932
933 // octave_swig_type plays the role of both the shadow class and the class
934 // representation within Octave, since there is no support for classes.
935 //
936 // These should really be decoupled, with the class support added to Octave
937 // and the shadow class given by an m-file script. That would dramatically
938 // reduce the runtime complexity, and be more in line w/ other modules.
939
940 class octave_swig_type:public octave_base_value {
941 struct cpp_ptr {
942 void *ptr;
943 bool destroyed;
944 cpp_ptr(void *_ptr):ptr(_ptr), destroyed(false) {
945 }};
946 typedef std::pair < const swig_type_info *, cpp_ptr > type_ptr_pair;
947
948 mutable swig_module_info *module;
949
950 const swig_type_info *construct_type; // type of special type object
951 std::vector < type_ptr_pair > types; // our c++ base classes
952 int own; // whether we call c++ destructors when we die
953
954 typedef std::pair < const swig_octave_member *, octave_value > member_value_pair;
955 typedef std::map < std::string, member_value_pair > member_map;
956 member_map members;
957 bool always_static;
958
959 const swig_octave_member *find_member(const swig_type_info *type, const std::string &name) {
960 if (!type->clientdata)
961 return 0;
962 swig_octave_class *c = (swig_octave_class *) type->clientdata;
963 const swig_octave_member *m;
964 for (m = c->members; m->name; ++m)
965 if (m->name == name)
966 return m;
967 for (int j = 0; c->base_names[j]; ++j) {
968 if (!c->base[j]) {
969 if (!module)
970 module = SWIG_GetModule(0);
971 assert(module);
972 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
973 }
974 if (!c->base[j])
975 return 0;
976 if ((m = find_member(c->base[j], name)))
977 return m;
978 }
979 return 0;
980 }
981
982 member_value_pair *find_member(const std::string &name, bool insert_if_not_found) {
983 member_map::iterator it = members.find(name);
984 if (it != members.end())
985 return &it->second;
986 const swig_octave_member *m;
987 for (unsigned int j = 0; j < types.size(); ++j)
988 if ((m = find_member(types[j].first, name)))
989 return &members.insert(std::make_pair(name, std::make_pair(m, octave_value()))).first->second;
990 if (!insert_if_not_found)
991 return 0;
992 return &members[name];
993 }
994
995 const swig_type_info *find_base(const std::string &name, const swig_type_info *base) {
996 if (!base) {
997 for (unsigned int j = 0; j < types.size(); ++j) {
998 assert(types[j].first->clientdata);
999 swig_octave_class *cj = (swig_octave_class *) types[j].first->clientdata;
1000 if (cj->name == name)
1001 return types[j].first;
1002 }
1003 return 0;
1004 }
1005 assert(base->clientdata);
1006 swig_octave_class *c = (swig_octave_class *) base->clientdata;
1007 for (int j = 0; c->base_names[j]; ++j) {
1008 if (!c->base[j]) {
1009 if (!module)
1010 module = SWIG_GetModule(0);
1011 assert(module);
1012 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1013 }
1014 if (!c->base[j])
1015 return 0;
1016 assert(c->base[j]->clientdata);
1017 swig_octave_class *cj = (swig_octave_class *) c->base[j]->clientdata;
1018 if (cj->name == name)
1019 return c->base[j];
1020 }
1021 return 0;
1022 }
1023
1024 void load_members(const swig_octave_class* c,member_map& out) const {
1025 for (const swig_octave_member *m = c->members; m->name; ++m) {
1026 if (out.find(m->name) == out.end())
1027 out.insert(std::make_pair(m->name, std::make_pair(m, octave_value())));
1028 }
1029 for (int j = 0; c->base_names[j]; ++j) {
1030 if (!c->base[j]) {
1031 if (!module)
1032 module = SWIG_GetModule(0);
1033 assert(module);
1034 c->base[j] = SWIG_MangledTypeQueryModule(module, module, c->base_names[j]);
1035 }
1036 if (!c->base[j])
1037 continue;
1038 assert(c->base[j]->clientdata);
1039 const swig_octave_class *cj =
1040 (const swig_octave_class *) c->base[j]->clientdata;
1041 load_members(cj,out);
1042 }
1043 }
1044
1045 void load_members(member_map& out) const {
1046 out=members;
1047 for (unsigned int j = 0; j < types.size(); ++j)
1048 if (types[j].first->clientdata)
1049 load_members((const swig_octave_class *) types[j].first->clientdata, out);
1050 }
1051
1052 octave_value_list member_invoke(member_value_pair *m, const octave_value_list &args, int nargout) {
1053 if (m->second.is_defined())
1054 return m->second.subsref("(", std::list < octave_value_list > (1, args), nargout);
1055 else if (m->first && m->first->method)
1056 return m->first->method(args, nargout);
1057 error("member not defined or not invocable");
1058 return octave_value_list();
1059 }
1060
1061 bool dispatch_unary_op(const std::string &symbol, octave_value &ret) {
1062 member_value_pair *m = find_member(symbol, false);
1063 if (!m || m->first->is_static() || m->first->is_global())
1064 return false;
1065 octave_value_list args;
1066 args.append(as_value());
1067 octave_value_list argout(member_invoke(m, args, 1));
1068 if (argout.length() < 1)
1069 return false;
1070 ret = argout(0);
1071 return true;
1072 }
1073
1074 bool dispatch_binary_op(const std::string &symbol, const octave_base_value &rhs, octave_value &ret) {
1075 member_value_pair *m = find_member(symbol, false);
1076 if (!m || m->first->is_static() || m->first->is_global())
1077 return false;
1078 octave_value_list args;
1079 args.append(as_value());
1080 args.append(make_value_hack(rhs));
1081 octave_value_list argout(member_invoke(m, args, 1));
1082 if (argout.length() < 1)
1083 return false;
1084 ret = argout(0);
1085 return true;
1086 }
1087
1088 bool dispatch_index_op(const std::string &symbol, const octave_value_list &rhs, octave_value_list &ret) {
1089 member_value_pair *m = find_member(symbol, false);
1090 if (!m || m->first->is_static() || m->first->is_global())
1091 return false;
1092 octave_value_list args;
1093 args.append(as_value());
1094 args.append(rhs);
1095 octave_value_list argout(member_invoke(m, args, 1));
1096 if (argout.length() >= 1)
1097 ret = argout(0);
1098 return true;
1099 }
1100
1101 octave_value_list member_deref(member_value_pair *m, const octave_value_list &args) {
1102 if (m->second.is_defined())
1103 return m->second;
1104 else if (m->first) {
1105 if (m->first->get_method)
1106 return m->first->get_method(args, 1);
1107 else if (m->first->method)
1108 return octave_value(new octave_builtin(m->first->method));
1109 }
1110 error("undefined member");
1111 return octave_value_list();
1112 }
1113
1114 static octave_value make_value_hack(const octave_base_value &x) {
1115 ((octave_swig_type &) x).count++;
1116 return octave_value((octave_base_value *) &x);
1117 }
1118
1119 octave_swig_type(const octave_swig_type &x);
1120 octave_swig_type &operator=(const octave_swig_type &rhs);
1121 public:
1122
1123 octave_swig_type(void *_ptr = 0, const swig_type_info *_type = 0, int _own = 0,
1124 bool _always_static = false)
1125 : module(0), construct_type(_ptr ? 0 : _type), own(_own),
1126 always_static(_always_static) {
1127 if (_type || _ptr)
1128 types.push_back(std::make_pair(_type, _ptr));
1129 #ifdef SWIG_DIRECTORS
1130 if (_ptr) {
1131 Swig::Director *d = Swig::get_rtdir(_ptr);
1132 if (d)
1133 Swig::swig_director_set_self(d, this);
1134 }
1135 #endif
1136 }
1137
1138 ~octave_swig_type() {
1139 if (own) {
1140 ++count;
1141 for (unsigned int j = 0; j < types.size(); ++j) {
1142 if (!types[j].first || !types[j].first->clientdata)
1143 continue;
1144 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1145 if (c->destructor && !types[j].second.destroyed && types[j].second.ptr) {
1146 c->destructor(as_value(), 0);
1147 }
1148 }
1149 }
1150 #ifdef SWIG_DIRECTORS
1151 for (unsigned int j = 0; j < types.size(); ++j)
1152 Swig::erase_rtdir(types[j].second.ptr);
1153 #endif
1154 }
1155
1156 dim_vector dims(void) const {
1157 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1158
1159 // Find the __dims__ method of this object
1160 member_value_pair *m = nc_this->find_member("__dims__", false);
1161
1162 if (!m) return dim_vector(1,1);
1163
1164 // Call the __dims__ method of this object
1165 octave_value_list inarg;
1166 inarg.append(nc_this->as_value());
1167 octave_value_list outarg = nc_this->member_invoke(m, inarg, 1);
1168
1169 // __dims__ should return (at least) one output argument
1170 if (outarg.length() < 1) return dim_vector(1,1);
1171
1172 octave_value & out = outarg(0);
1173
1174 // Return value should be cell or matrix of integers
1175 if (out.is_cell()) {
1176 const Cell & c=out.cell_value();
1177 int ndim = c.rows();
1178 if (ndim==1 && c.columns()!=1) ndim = c.columns();
1179
1180 dim_vector d;
1181 d.resize(ndim < 2 ? 2 : ndim);
1182 d(0) = d(1) = 1;
1183
1184 // Fill in dim_vector
1185 for (int k=0;k<ndim;k++) {
1186 const octave_value& obj = c(k);
1187 d.elem(k) = obj.int_value();
1188
1189 // __dims__ should return a cell filled with integers
1190 if (error_state) return dim_vector(1,1);
1191 }
1192 return d;
1193 } else if (out.is_matrix_type() || out.is_real_nd_array() || out.is_numeric_type() ) {
1194 if (out.rows()==1 || out.columns()==1) {
1195 Array<int> a = out.int_vector_value();
1196 if (error_state) return dim_vector(1,1);
1197 dim_vector d;
1198 d.resize(a.numel() < 2 ? 2 : a.numel());
1199 d(0) = d(1) = 1;
1200 for (int k=0;k<a.numel();k++) {
1201 d.elem(k) = a(k);
1202 }
1203 return d;
1204 } else {
1205 return dim_vector(1,1);
1206 }
1207 } else {
1208 return dim_vector(1,1);
1209 }
1210 }
1211
1212 octave_value as_value() {
1213 ++count;
1214 return Swig::swig_value_ref(this);
1215 }
1216
1217 void incref() {
1218 ++count;
1219 }
1220
1221 void decref() {
1222 if (!--count)
1223 delete this;
1224 }
1225
1226 long swig_this() const {
1227 if (!types.size())
1228 return (long) this;
1229 return (long) types[0].second.ptr;
1230 }
1231 const char* help_text() const {
1232 if (!types.size())
1233 return 0;
1234 if (!types[0].first->clientdata)
1235 return 0;
1236 swig_octave_class *c = (swig_octave_class *) types[0].first->clientdata;
1237 return c->constructor_doc;
1238 }
1239
1240 std::string swig_type_name() const {
1241 // * need some way to manually name subclasses.
1242 // * eg optional first arg to subclass(), or named_subclass()
1243 std::string ret;
1244 for (unsigned int j = 0; j < types.size(); ++j) {
1245 if (j)
1246 ret += "_";
1247 if (types[j].first->clientdata) {
1248 swig_octave_class *c = (swig_octave_class *) types[j].first->clientdata;
1249 ret += c->name;
1250 } else
1251 ret += types[j].first->name;
1252 }
1253 return ret;
1254 }
1255
1256 void merge(octave_swig_type &rhs) {
1257 rhs.own = 0;
1258 for (unsigned int j = 0; j < rhs.types.size(); ++j) {
1259 assert(!rhs.types[j].second.destroyed);
1260 #ifdef SWIG_DIRECTORS
1261 Swig::Director *d = Swig::get_rtdir(rhs.types[j].second.ptr);
1262 if (d)
1263 Swig::swig_director_set_self(d, this);
1264 #endif
1265 }
1266 types.insert(types.end(), rhs.types.begin(), rhs.types.end());
1267 members.insert(rhs.members.begin(), rhs.members.end());
1268 rhs.types.clear();
1269 rhs.members.clear();
1270 }
1271
1272 typedef member_map::const_iterator swig_member_const_iterator;
1273 swig_member_const_iterator swig_members_begin() { return members.begin(); }
1274 swig_member_const_iterator swig_members_end() { return members.end(); }
1275
1276 void *cast(swig_type_info *type, int *_own, int flags) {
1277 if (_own)
1278 *_own = own;
1279 if (flags &SWIG_POINTER_DISOWN)
1280 own = 0;
1281 if (!type && types.size())
1282 return types[0].second.ptr;
1283 for (unsigned int j = 0; j < types.size(); ++j)
1284 if (type == types[j].first)
1285 return types[j].second.ptr;
1286 for (unsigned int j = 0; j < types.size(); ++j) {
1287 swig_cast_info *tc = SWIG_TypeCheck(types[j].first->name, type);
1288 if (!tc)
1289 continue;
1290 int newmemory = 0;
1291 void *vptr = SWIG_TypeCast(tc, types[j].second.ptr, &newmemory);
1292 assert(!newmemory); // newmemory handling not yet implemented
1293 return vptr;
1294 }
1295 return 0;
1296 }
1297
1298 bool is_owned() const {
1299 return own;
1300 }
1301
1302 #ifdef SWIG_DIRECTORS
1303 void director_destroyed(Swig::Director *d) {
1304 bool found = false;
1305 for (unsigned int j = 0; j < types.size(); ++j) {
1306 Swig::Director *dj = Swig::get_rtdir(types[j].second.ptr);
1307 if (dj == d) {
1308 types[j].second.destroyed = true;
1309 found = true;
1310 }
1311 }
1312 assert(found);
1313 }
1314 #endif
1315
1316 void assign(const std::string &name, const octave_value &ov) {
1317 members[name] = std::make_pair((const swig_octave_member *) 0, ov);
1318 }
1319
1320 void assign(const std::string &name, const swig_octave_member *m) {
1321 members[name] = std::make_pair(m, octave_value());
1322 }
1323
1324 octave_base_value *clone() const {
1325 // pass-by-value is probably not desired, and is harder;
1326 // requires calling copy constructors of contained types etc.
1327 assert(0);
1328 *(int *) 0 = 0;
1329 return 0;
1330 }
1331
1332 octave_base_value *empty_clone() const {
1333 return new octave_swig_type();
1334 }
1335
1336 bool is_defined() const {
1337 return true;
1338 }
1339
1340 virtual bool is_map() const {
1341 return true;
1342 }
1343
1344 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx) {
1345 octave_value_list ovl = subsref(ops, idx, 1);
1346 return ovl.length()? ovl(0) : octave_value();
1347 }
1348
1349 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout) {
1350 assert(ops.size() > 0);
1351 assert(ops.size() == idx.size());
1352
1353 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1354 int skip = 0;
1355 octave_value_list sub_ovl;
1356
1357 // constructor invocation
1358 if (ops[skip] == '(' && construct_type) {
1359 assert(construct_type->clientdata);
1360 swig_octave_class *c = (swig_octave_class *) construct_type->clientdata;
1361 if (!c->constructor) {
1362 error("cannot create instance");
1363 return octave_value_list();
1364 }
1365 octave_value_list args;
1366 if (c->director)
1367 args.append(Swig::swig_value_ref(new octave_swig_type(this, 0, 0)));
1368 args.append(*idx_it++);
1369 ++skip;
1370 sub_ovl = c->constructor(args, nargout);
1371 }
1372 // member dereference or invocation
1373 else if (ops[skip] == '.') {
1374 std::string subname;
1375 const swig_type_info *base = 0; // eg, a.base.base_cpp_mem
1376 for (;;) {
1377 octave_value_list subname_ovl(*idx_it++);
1378 ++skip;
1379 assert(subname_ovl.length() == 1 && subname_ovl(0).is_string());
1380 subname = subname_ovl(0).string_value();
1381
1382 const swig_type_info *next_base = find_base(subname, base);
1383 if (!next_base || skip >= (int) ops.size() || ops[skip] != '.')
1384 break;
1385 base = next_base;
1386 }
1387
1388 member_value_pair tmp, *m = &tmp;
1389 if (!base || !(m->first = find_member(base, subname)))
1390 m = find_member(subname, false);
1391 if (!m) {
1392 error("member not found");
1393 return octave_value_list();
1394 }
1395
1396 octave_value_list args;
1397 if (!always_static &&
1398 (!m->first || (!m->first->is_static() && !m->first->is_global())))
1399 args.append(as_value());
1400 if (skip < (int) ops.size() && ops[skip] == '(' &&
1401 ((m->first && m->first->method) || m->second.is_function() ||
1402 m->second.is_function_handle())) {
1403 args.append(*idx_it++);
1404 ++skip;
1405 sub_ovl = member_invoke(m, args, nargout);
1406 } else {
1407 sub_ovl = member_deref(m, args);
1408 }
1409 }
1410 // index operator
1411 else {
1412 if (ops[skip] == '(' || ops[skip] == '{') {
1413 const char *op_name = ops[skip] == '(' ? "__paren__" : "__brace__";
1414 octave_value_list args;
1415 args.append(*idx_it++);
1416 ++skip;
1417 if (!dispatch_index_op(op_name, args, sub_ovl)) {
1418 error("error evaluating index operator");
1419 return octave_value_list();
1420 }
1421 } else {
1422 error("unsupported subsref");
1423 return octave_value_list();
1424 }
1425 }
1426
1427 if (skip >= (int) ops.size())
1428 return sub_ovl;
1429 if (sub_ovl.length() < 1) {
1430 error("bad subs ref");
1431 return octave_value_list();
1432 }
1433 return sub_ovl(0).next_subsref(nargout, ops, idx, skip);
1434 }
1435
1436 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs) {
1437 assert(ops.size() > 0);
1438 assert(ops.size() == idx.size());
1439
1440 std::list < octave_value_list >::const_iterator idx_it = idx.begin();
1441 int skip = 0;
1442
1443 if (ops.size() > 1) {
1444 std::list < octave_value_list >::const_iterator last = idx.end();
1445 --last;
1446 std::list < octave_value_list > next_idx(idx.begin(), last);
1447 octave_value next_ov = subsref(ops.substr(0, ops.size() - 1), next_idx);
1448 next_ov.subsasgn(ops.substr(ops.size() - 1), std::list < octave_value_list > (1, *last), rhs);
1449 }
1450
1451 else if (ops[skip] == '(' || ops[skip] == '{') {
1452 const char *op_name = ops[skip] == '(' ? "__paren_asgn__" : "__brace_asgn__";
1453 member_value_pair *m = find_member(op_name, false);
1454 if (m) {
1455 octave_value_list args;
1456 args.append(as_value());
1457 args.append(*idx_it);
1458 args.append(rhs);
1459 member_invoke(m, args, 1);
1460 } else
1461 error("%s member not found", op_name);
1462 }
1463
1464 else if (ops[skip] == '.') {
1465 octave_value_list subname_ovl(*idx_it++);
1466 ++skip;
1467 assert(subname_ovl.length() == 1 &&subname_ovl(0).is_string());
1468 std::string subname = subname_ovl(0).string_value();
1469
1470 member_value_pair *m = find_member(subname, true);
1471 if (!m->first || !m->first->set_method) {
1472 m->first = 0;
1473 m->second = rhs;
1474 } else if (m->first->set_method) {
1475 octave_value_list args;
1476 if (!m->first->is_static() && !m->first->is_global())
1477 args.append(as_value());
1478 args.append(rhs);
1479 m->first->set_method(args, 1);
1480 } else
1481 error("member not assignable");
1482 } else
1483 error("unsupported subsasgn");
1484
1485 return as_value();
1486 }
1487
1488 virtual bool is_object() const {
1489 return true;
1490 }
1491
1492 virtual bool is_string() const {
1493 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1494 return !!nc_this->find_member("__str__", false);
1495 }
1496
1497 virtual std::string string_value(bool force = false) const {
1498 octave_swig_type *nc_this = const_cast < octave_swig_type *>(this);
1499 member_value_pair *m = nc_this->find_member("__str__", false);
1500 if (!m) {
1501 error("__str__ method not defined");
1502 return std::string();
1503 }
1504 octave_value_list outarg = nc_this->member_invoke(m, octave_value_list(nc_this->as_value()), 1);
1505 if (outarg.length() < 1 || !outarg(0).is_string()) {
1506 error("__str__ method did not return a string");
1507 return std::string();
1508 }
1509 return outarg(0).string_value();
1510 }
1511
1512 #if OCTAVE_API_VERSION_NUMBER >= 40
1513 virtual octave_map map_value() const {
1514 return octave_map();
1515 }
1516 #else
1517 virtual Octave_map map_value() const {
1518 return Octave_map();
1519 }
1520 #endif
1521
1522 virtual string_vector map_keys() const {
1523 member_map tmp;
1524 load_members(tmp);
1525
1526 string_vector keys(tmp.size());
1527 int k = 0;
1528 for (member_map::iterator it = tmp.begin(); it != tmp.end(); ++it)
1529 keys(k++) = it->first;
1530
1531 return keys;
1532 }
1533
1534 virtual bool save_ascii (std::ostream& os) {
1535 return true;
1536 }
1537
1538 virtual bool load_ascii (std::istream& is) {
1539 return true;
1540 }
1541
1542 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1543 return true;
1544 }
1545
1546 virtual bool load_binary (std::istream& is, bool swap,
1547 oct_mach_info::float_format fmt) {
1548 return true;
1549 }
1550
1551 #if defined (HAVE_HDF5)
1552 virtual bool
1553 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1554 return true;
1555 }
1556
1557 virtual bool
1558 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1559 return true;
1560 }
1561 #endif
1562
1563 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const {
1564 return string_value();
1565 }
1566
1567 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const {
1568 return string_value();
1569 }
1570
1571 static bool dispatch_global_op(const std::string &symbol, const octave_value_list &args, octave_value &ret) {
1572 // we assume that SWIG_op_prefix-prefixed functions are installed in global namespace
1573 // (rather than any module namespace).
1574
1575 octave_function *fcn = is_valid_function(symbol, std::string(), false);
1576 if (!fcn)
1577 return false;
1578 ret = fcn->do_multi_index_op(1, args)(0);
1579 return true;
1580 }
1581
1582 static octave_value dispatch_unary_op(const octave_base_value &x, const char *op_name) {
1583 octave_swig_type *ost = Swig::swig_value_deref(x);
1584 assert(ost);
1585
1586 octave_value ret;
1587 if (ost->dispatch_unary_op(std::string("__") + op_name + std::string("__"), ret))
1588 return ret;
1589 std::string symbol = SWIG_op_prefix + ost->swig_type_name() + "_" + op_name;
1590 octave_value_list args;
1591 args.append(make_value_hack(x));
1592 if (dispatch_global_op(symbol, args, ret))
1593 return ret;
1594
1595 error("could not dispatch unary operator");
1596 return octave_value();
1597 }
1598
1599 static octave_value dispatch_binary_op(const octave_base_value &lhs, const octave_base_value &rhs, const char *op_name) {
1600 octave_swig_type *lhs_ost = Swig::swig_value_deref(lhs);
1601 octave_swig_type *rhs_ost = Swig::swig_value_deref(rhs);
1602
1603 octave_value ret;
1604 if (lhs_ost && lhs_ost->dispatch_binary_op(std::string("__") + op_name + std::string("__"), rhs, ret))
1605 return ret;
1606 if (rhs_ost) {
1607 if (strlen(op_name) == 2 && (op_name[1] == 't' || op_name[1] == 'e')) {
1608 if (op_name[0] == 'l' && rhs_ost->dispatch_binary_op(std::string("__g") + op_name[1] + std::string("__"), lhs, ret))
1609 return ret;
1610 if (op_name[0] == 'g' && rhs_ost->dispatch_binary_op(std::string("__l") + op_name[1] + std::string("__"), lhs, ret))
1611 return ret;
1612 }
1613 if (rhs_ost->dispatch_binary_op(std::string("__r") + op_name + std::string("__"), lhs, ret))
1614 return ret;
1615 }
1616
1617 std::string symbol;
1618 octave_value_list args;
1619 args.append(make_value_hack(lhs));
1620 args.append(make_value_hack(rhs));
1621
1622 symbol = SWIG_op_prefix;
1623 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1624 symbol += "_";
1625 symbol += op_name;
1626 symbol += "_";
1627 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1628 if (dispatch_global_op(symbol, args, ret))
1629 return ret;
1630
1631 symbol = SWIG_op_prefix;
1632 symbol += lhs_ost ? lhs_ost->swig_type_name() : lhs.type_name();
1633 symbol += "_";
1634 symbol += op_name;
1635 symbol += "_";
1636 symbol += "any";
1637 if (dispatch_global_op(symbol, args, ret))
1638 return ret;
1639
1640 symbol = SWIG_op_prefix;
1641 symbol += "any";
1642 symbol += "_";
1643 symbol += op_name;
1644 symbol += "_";
1645 symbol += rhs_ost ? rhs_ost->swig_type_name() : rhs.type_name();
1646 if (dispatch_global_op(symbol, args, ret))
1647 return ret;
1648
1649 error("could not dispatch binary operator");
1650 return octave_value();
1651 }
1652
1653 void print(std::ostream &os, bool pr_as_read_syntax = false) const {
1654 if (is_string()) {
1655 os << string_value();
1656 return;
1657 }
1658
1659 member_map tmp;
1660 load_members(tmp);
1661
1662 indent(os);
1663 os << "{"; newline(os);
1664 increment_indent_level();
1665 for (unsigned int j = 0; j < types.size(); ++j) {
1666 indent(os);
1667 if (types[j].first->clientdata) {
1668 const swig_octave_class *c = (const swig_octave_class *) types[j].first->clientdata;
1669 os << c->name << ", ptr = " << types[j].second.ptr; newline(os);
1670 } else {
1671 os << types[j].first->name << ", ptr = " << types[j].second.ptr; newline(os);
1672 }
1673 }
1674 for (member_map::const_iterator it = tmp.begin(); it != tmp.end(); ++it) {
1675 indent(os);
1676 if (it->second.first) {
1677 const char *objtype = it->second.first->method ? "method" : "variable";
1678 const char *modifier = (it->second.first->flags &1) ? "static " : (it->second.first->flags &2) ? "global " : "";
1679 os << it->second.first->name << " (" << modifier << objtype << ")"; newline(os);
1680 assert(it->second.first->name == it->first);
1681 } else {
1682 os << it->first; newline(os);
1683 }
1684 }
1685 decrement_indent_level();
1686 indent(os);
1687 os << "}"; newline(os);
1688 }
1689 };
1690
1691 // Octave tries hard to preserve pass-by-value semantics. Eg, assignments
1692 // will call clone() via make_unique() if there is more than one outstanding
1693 // reference to the lhs, and forces the clone's reference count to 1
1694 // (so you can't just increment your own count and return this).
1695 //
1696 // One way to fix this (without modifying Octave) is to add a level of
1697 // indirection such that clone copies ref-counted pointer and we keep
1698 // pass-by-ref semantics (which are more natural/expected for C++ bindings).
1699 //
1700 // Supporting both pass-by-{ref,value} and toggling via %feature/option
1701 // might be nice.
1702
1703 class octave_swig_ref:public octave_base_value {
1704 octave_swig_type *ptr;
1705 public:
1706 octave_swig_ref(octave_swig_type *_ptr = 0)
1707 :ptr(_ptr) { }
1708
1709 ~octave_swig_ref()
1710 { if (ptr) ptr->decref(); }
1711
1712 octave_swig_type *get_ptr() const
1713 { return ptr; }
1714
1715 octave_base_value *clone() const
1716 { if (ptr) ptr->incref(); return new octave_swig_ref(ptr); }
1717
1718 octave_base_value *empty_clone() const
1719 { return new octave_swig_ref(0); }
1720
1721 dim_vector dims(void) const
1722 { return ptr->dims(); }
1723
1724 bool is_defined() const
1725 { return ptr->is_defined(); }
1726
1727 virtual bool is_map() const
1728 { return ptr->is_map(); }
1729
1730 virtual octave_value subsref(const std::string &ops, const std::list < octave_value_list > &idx)
1731 { return ptr->subsref(ops, idx); }
1732
1733 virtual octave_value_list subsref(const std::string &ops, const std::list < octave_value_list > &idx, int nargout)
1734 { return ptr->subsref(ops, idx, nargout); }
1735
1736 octave_value subsasgn(const std::string &ops, const std::list < octave_value_list > &idx, const octave_value &rhs)
1737 { return ptr->subsasgn(ops, idx, rhs); }
1738
1739 virtual bool is_object() const
1740 { return ptr->is_object(); }
1741
1742 virtual bool is_string() const
1743 { return ptr->is_string(); }
1744
1745 virtual std::string string_value(bool force = false) const
1746 { return ptr->string_value(force); }
1747
1748 #if OCTAVE_API_VERSION_NUMBER >= 40
1749 virtual octave_map map_value() const
1750 { return ptr->map_value(); }
1751 #else
1752 virtual Octave_map map_value() const
1753 { return ptr->map_value(); }
1754 #endif
1755
1756 virtual string_vector map_keys() const
1757 { return ptr->map_keys(); }
1758
1759 virtual bool save_ascii (std::ostream& os)
1760 { return ptr->save_ascii(os); }
1761
1762 virtual bool load_ascii (std::istream& is)
1763 { return ptr->load_ascii(is); }
1764
1765 virtual bool save_binary (std::ostream& os, bool& save_as_floats)
1766 { return ptr->save_binary(os, save_as_floats); }
1767
1768 virtual bool load_binary (std::istream& is, bool swap,
1769 oct_mach_info::float_format fmt)
1770 { return ptr->load_binary(is, swap, fmt); }
1771
1772 #if defined (HAVE_HDF5)
1773 virtual bool
1774 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats)
1775 { return ptr->save_hdf5(loc_id, name, save_as_floats); }
1776
1777 virtual bool
1778 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug)
1779 { return ptr->load_hdf5(loc_id, name, have_h5giterate_bug); }
1780 #endif
1781
1782 virtual octave_value convert_to_str(bool pad = false, bool force = false, char type = '"') const
1783 { return ptr->convert_to_str(pad, force, type); }
1784
1785 virtual octave_value convert_to_str_internal(bool pad, bool force, char type) const
1786 { return ptr->convert_to_str_internal(pad, force, type); }
1787
1788 void print(std::ostream &os, bool pr_as_read_syntax = false) const
1789 { return ptr->print(os, pr_as_read_syntax); }
1790
1791 private:
1792 DECLARE_OCTAVE_ALLOCATOR;
1793 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;
1794 };
1795 DEFINE_OCTAVE_ALLOCATOR(octave_swig_ref);
1796 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_ref, "swig_ref", "swig_ref");
1797
1798 class octave_swig_packed:public octave_base_value {
1799 swig_type_info *type;
1800 std::vector < char > buf;
1801 public:
1802
1803 octave_swig_packed(swig_type_info *_type = 0, const void *_buf = 0, size_t _buf_len = 0)
1804 : type(_type), buf((const char*)_buf, (const char*)_buf + _buf_len) {
1805 }
1806
1807 bool copy(swig_type_info *outtype, void *ptr, size_t sz) const {
1808 if (outtype && outtype != type)
1809 return false;
1810 assert(sz <= buf.size());
1811 std::copy(buf.begin(), buf.begin()+sz, (char*)ptr);
1812 return true;
1813 }
1814
1815 octave_base_value *clone() const {
1816 return new octave_swig_packed(*this);
1817 }
1818
1819 octave_base_value *empty_clone() const {
1820 return new octave_swig_packed();
1821 }
1822
1823 bool is_defined() const {
1824 return true;
1825 }
1826
1827 void print(std::ostream &os, bool pr_as_read_syntax = false) const {
1828 indent(os);
1829 os << "swig packed type: name = " << (type ? type->name : std::string()) << ", len = " << buf.size(); newline(os);
1830 }
1831
1832
1833 virtual bool save_ascii (std::ostream& os) {
1834 return true;
1835 }
1836
1837 virtual bool load_ascii (std::istream& is) {
1838 return true;
1839 }
1840
1841 virtual bool save_binary (std::ostream& os, bool& save_as_floats) {
1842 return true;
1843 }
1844
1845 virtual bool load_binary (std::istream& is, bool swap,
1846 oct_mach_info::float_format fmt) {
1847 return true;
1848 }
1849
1850 #if defined (HAVE_HDF5)
1851 virtual bool
1852 save_hdf5 (hid_t loc_id, const char *name, bool save_as_floats) {
1853 return true;
1854 }
1855
1856 virtual bool
1857 load_hdf5 (hid_t loc_id, const char *name, bool have_h5giterate_bug) {
1858 return true;
1859 }
1860 #endif
1861
1862 private:
1863 DECLARE_OCTAVE_ALLOCATOR;
1864 DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA;
1865 };
1866 DEFINE_OCTAVE_ALLOCATOR(octave_swig_packed);
1867 DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA(octave_swig_packed, "swig_packed", "swig_packed");
1868
1869 static octave_value_list octave_set_immutable(const octave_value_list &args, int nargout) {
1870 error("attempt to set immutable member variable");
1871 return octave_value_list();
1872 }
1873
1874 struct octave_value_ref {
1875 const octave_value_list &ovl;
1876 int j;
1877
1878 octave_value_ref(const octave_value_list &_ovl, int _j)
1879 :ovl(_ovl), j(_j) { }
1880
1881 operator octave_value() const {
1882 return ovl(j);
1883 }
1884
1885 octave_value operator*() const {
1886 return ovl(j);
1887 }
1888 };
1889
1890
1891 namespace Swig {
1892
1893 SWIGRUNTIME octave_base_value *swig_value_ref(octave_swig_type *ost) {
1894 return new octave_swig_ref(ost);
1895 }
1896
1897 SWIGRUNTIME octave_swig_type *swig_value_deref(octave_value ov) {
1898 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
1899 ov = ov.cell_value()(0);
1900 return swig_value_deref(*ov.internal_rep());
1901 }
1902
1903 SWIGRUNTIME octave_swig_type *swig_value_deref(const octave_base_value &ov) {
1904 if (ov.type_id() != octave_swig_ref::static_type_id())
1905 return 0;
1906 const octave_swig_ref *osr = static_cast < const octave_swig_ref *>(&ov);
1907 return osr->get_ptr();
1908 }
1909
1910 }
1911
1912
1913 #define swig_unary_op(name) \
1914 SWIGRUNTIME octave_value swig_unary_op_##name(const octave_base_value &x) { \
1915 return octave_swig_type::dispatch_unary_op(x,#name); \
1916 }
1917 #define swig_binary_op(name) \
1918 SWIGRUNTIME octave_value swig_binary_op_##name(const octave_base_value&lhs,const octave_base_value &rhs) { \
1919 return octave_swig_type::dispatch_binary_op(lhs,rhs,#name); \
1920 }
1921 #define swigreg_unary_op(name) \
1922 if (!octave_value_typeinfo::lookup_unary_op(octave_value::op_##name,tid)) \
1923 octave_value_typeinfo::register_unary_op(octave_value::op_##name,tid,swig_unary_op_##name);
1924 #define swigreg_binary_op(name) \
1925 if (!octave_value_typeinfo::lookup_binary_op(octave_value::op_##name,tid1,tid2)) \
1926 octave_value_typeinfo::register_binary_op(octave_value::op_##name,tid1,tid2,swig_binary_op_##name);
1927
1928 swig_unary_op(not);
1929 swig_unary_op(uplus);
1930 swig_unary_op(uminus);
1931 swig_unary_op(transpose);
1932 swig_unary_op(hermitian);
1933 swig_unary_op(incr);
1934 swig_unary_op(decr);
1935
1936 swig_binary_op(add);
1937 swig_binary_op(sub);
1938 swig_binary_op(mul);
1939 swig_binary_op(div);
1940 swig_binary_op(pow);
1941 swig_binary_op(ldiv);
1942 swig_binary_op(lshift);
1943 swig_binary_op(rshift);
1944 swig_binary_op(lt);
1945 swig_binary_op(le);
1946 swig_binary_op(eq);
1947 swig_binary_op(ge);
1948 swig_binary_op(gt);
1949 swig_binary_op(ne);
1950 swig_binary_op(el_mul);
1951 swig_binary_op(el_div);
1952 swig_binary_op(el_pow);
1953 swig_binary_op(el_ldiv);
1954 swig_binary_op(el_and);
1955 swig_binary_op(el_or);
1956
1957 SWIGRUNTIME void SWIG_InstallUnaryOps(int tid) {
1958 swigreg_unary_op(not);
1959 swigreg_unary_op(uplus);
1960 swigreg_unary_op(uminus);
1961 swigreg_unary_op(transpose);
1962 swigreg_unary_op(hermitian);
1963 swigreg_unary_op(incr);
1964 swigreg_unary_op(decr);
1965 }
1966 SWIGRUNTIME void SWIG_InstallBinaryOps(int tid1, int tid2) {
1967 swigreg_binary_op(add);
1968 swigreg_binary_op(sub);
1969 swigreg_binary_op(mul);
1970 swigreg_binary_op(div);
1971 swigreg_binary_op(pow);
1972 swigreg_binary_op(ldiv);
1973 swigreg_binary_op(lshift);
1974 swigreg_binary_op(rshift);
1975 swigreg_binary_op(lt);
1976 swigreg_binary_op(le);
1977 swigreg_binary_op(eq);
1978 swigreg_binary_op(ge);
1979 swigreg_binary_op(gt);
1980 swigreg_binary_op(ne);
1981 swigreg_binary_op(el_mul);
1982 swigreg_binary_op(el_div);
1983 swigreg_binary_op(el_pow);
1984 swigreg_binary_op(el_ldiv);
1985 swigreg_binary_op(el_and);
1986 swigreg_binary_op(el_or);
1987 }
1988 SWIGRUNTIME void SWIG_InstallOps(int tid) {
1989 // here we assume that tid are conseq integers increasing from zero, and
1990 // that our tid is the last one. might be better to have explicit string
1991 // list of types we should bind to, and use lookup_type to resolve their tid.
1992
1993 SWIG_InstallUnaryOps(tid);
1994 SWIG_InstallBinaryOps(tid, tid);
1995 for (int j = 0; j < tid; ++j) {
1996 SWIG_InstallBinaryOps(j, tid);
1997 SWIG_InstallBinaryOps(tid, j);
1998 }
1999 }
2000
2001 SWIGRUNTIME octave_value SWIG_Octave_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2002 int own = (flags &SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2003
2004 #ifdef SWIG_DIRECTORS
2005 Swig::Director *d = Swig::get_rtdir(ptr);
2006 if (d && Swig::swig_director_get_self(d))
2007 return Swig::swig_director_get_self(d)->as_value();
2008 #endif
2009 return Swig::swig_value_ref(new octave_swig_type(ptr, type, own));
2010 }
2011
2012 SWIGRUNTIME int SWIG_Octave_ConvertPtrAndOwn(octave_value ov, void **ptr, swig_type_info *type, int flags, int *own) {
2013 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2014 ov = ov.cell_value()(0);
2015 if (!ov.is_defined() ||
2016 (ov.is_matrix_type() && ov.rows() == 0 && ov.columns() == 0) ) {
2017 if (ptr)
2018 *ptr = 0;
2019 return SWIG_OK;
2020 }
2021 if (ov.type_id() != octave_swig_ref::static_type_id())
2022 return SWIG_ERROR;
2023 octave_swig_ref *osr = static_cast < octave_swig_ref *>(ov.internal_rep());
2024 octave_swig_type *ost = osr->get_ptr();
2025 void *vptr = ost->cast(type, own, flags);
2026 if (!vptr)
2027 return SWIG_ERROR;
2028 if (ptr)
2029 *ptr = vptr;
2030 return SWIG_OK;
2031 }
2032
2033 SWIGRUNTIME octave_value SWIG_Octave_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2034 return new octave_swig_packed(type, (char *) ptr, sz);
2035 }
2036
2037 SWIGRUNTIME int SWIG_Octave_ConvertPacked(const octave_value &ov, void *ptr, size_t sz, swig_type_info *type) {
2038 if (!ov.is_defined())
2039 return SWIG_ERROR;
2040 if (ov.type_id() != octave_swig_packed::static_type_id())
2041 return SWIG_ERROR;
2042 octave_swig_packed *ost = static_cast < octave_swig_packed *>(ov.internal_rep());
2043 return ost->copy(type, (char *) ptr, sz) ? SWIG_OK : SWIG_ERROR;
2044 }
2045
2046 void SWIG_Octave_SetConstant(octave_swig_type *module_ns, const std::string &name, const octave_value &ov) {
2047 module_ns->assign(name, ov);
2048 }
2049
2050 SWIGRUNTIMEINLINE octave_value SWIG_Octave_GetGlobalValue(std::string name) {
2051 return get_global_value(name, true);
2052 }
2053
2054 SWIGRUNTIME void SWIG_Octave_SetGlobalValue(std::string name, const octave_value& value) {
2055 // It is critical that a newly-allocated octave_value is passed to set_global_value(),
2056 // since it and the Octave symbol table take references to the values assigned to it.
2057 // If we were to pass a reference to 'value' to set_global_value(), then the Octave
2058 // symbol table would hold a reference to a variable owned by the SWIG .oct module.
2059 // Both will think that they own the reference (since the .oct module is dynamically
2060 // loaded, it appears to have its own C++ runtime), and so they will both try to
2061 // de-allocate the octave_value on exit, resulting in a double-free or seg-fault.
2062 // This is prevented by giving Octave its own heap-allocated copy of 'value'.
2063 octave_value *pov = new octave_value(value);
2064 set_global_value(name, *pov);
2065 }
2066
2067 SWIGRUNTIME void SWIG_Octave_LinkGlobalValue(std::string name) {
2068 #if OCTAVE_API_VERSION_NUMBER < 37
2069 link_to_global_variable(curr_sym_tab->lookup(name, true));
2070 #else
2071 symbol_table::varref(name);
2072 symbol_table::mark_global(name);
2073 #endif
2074 }
2075
2076 SWIGRUNTIME swig_module_info *SWIG_Octave_GetModule(void *clientdata) {
2077 octave_value ov = SWIG_Octave_GetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION);
2078 if (!ov.is_defined() ||
2079 ov.type_id() != octave_swig_packed::static_type_id())
2080 return 0;
2081 const octave_swig_packed* osp =
2082 static_cast < const octave_swig_packed *> (ov.internal_rep());
2083 swig_module_info *pointer = 0;
2084 osp->copy(0, &pointer, sizeof(swig_module_info *));
2085 return pointer;
2086 }
2087
2088 SWIGRUNTIME void SWIG_Octave_SetModule(void *clientdata, swig_module_info *pointer) {
2089 octave_value ov = new octave_swig_packed(0, &pointer, sizeof(swig_module_info *));
2090 SWIG_Octave_SetGlobalValue("__SWIG_MODULE__" SWIG_TYPE_TABLE_NAME SWIG_RUNTIME_VERSION, ov);
2091 }
2092
2093
2094
2095 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2096
2097 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2098
2099
2100
2101 /* -------- TYPES TABLE (BEGIN) -------- */
2102
2103 #define SWIGTYPE_p_PLGraphicsIn swig_types[0]
2104 #define SWIGTYPE_p_char swig_types[1]
2105 #define SWIGTYPE_p_double swig_types[2]
2106 #define SWIGTYPE_p_f_double_double_p_double_p_double_p_void__void swig_types[3]
2107 #define SWIGTYPE_p_f_int_double_p_char_int_p_void__void swig_types[4]
2108 #define SWIGTYPE_p_f_int_p_double_p_double__void swig_types[5]
2109 #define SWIGTYPE_p_int swig_types[6]
2110 #define SWIGTYPE_p_p_char swig_types[7]
2111 #define SWIGTYPE_p_unsigned_int swig_types[8]
2112 static swig_type_info *swig_types[10];
2113 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
2114 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2115 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2116
2117 /* -------- TYPES TABLE (END) -------- */
2118
2119
2120 #define SWIGVERSION 0x020007
2121 #define SWIG_VERSION SWIGVERSION
2122
2123
2124 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2125 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2126
2127
2128 #include <stdexcept>
2129
2130
2131 // #undef PACKAGE and VERSION macros which are leaked out by the octave headers
2132 #undef PACKAGE
2133 #undef VERSION
2134
2135 #include "plplotP.h"
2136
2137 // Temporary fix for problems with -fvisibility=hidden and octave headers.
2138 #ifdef OCTAVE_EXPORT
2139 #if defined ( __GNUC__ ) && __GNUC__ > 3
2140 #undef OCTAVE_EXPORT
2141 #define OCTAVE_EXPORT __attribute__ ( ( visibility( "default" ) ) )
2142 #endif
2143 #endif
2144
2145
2146
2147 // I hate global variables but this is the best way I can think of
2148 // to manage consistency checking among function arguments.
2149 static PLINT Alen = 0;
2150 static PLINT Xlen = 0, Ylen = 0;
2151
2152
2153 // Convenience functions copied from matwrap-based approach (currently
2154 // stored in bindings/octave/matwrap/wrap_octave.pl) to take care of the
2155 // tricky scalar case and also adopted so that the resulting
2156 // swig-generated source code will look similar to the matwrap-generated
2157 // source code.
2158
2159 inline int max( int a, int b )
2160 {
2161 return a >= b ? a : b;
2162 }
2163 inline int min( int a, int b )
2164 {
2165 return a >= b ? a : b;
2166 }
2167
2168 //
2169 // Function to get the total length (rows*columns) of an octave object of
2170 // arbitrary type.
2171 // Arguments:
2172 // 1) The octave object.
2173 //
2174 // If the object is a scalar, the array length is 1.
2175 //
2176 static int
2177 _arraylen( const octave_value &o_obj )
2178 {
2179 return max( o_obj.rows(), 1 ) * max( o_obj.columns(), 1 ); // Return the size.
2180 // max is necessary because sometimes
2181 // rows() or columns() return -1 or 0 for
2182 // scalars.
2183 }
2184
2185 //
2186 // Function to get the number of dimensions of an object.
2187 //
2188 static int
2189 _n_dims( const octave_value &o_obj )
2190 {
2191 if ( max( o_obj.columns(), 1 ) > 1 )
2192 return 2;
2193 // max is necessary because sometimes
2194 // rows() or columns() return -1 or 0 for
2195 // scalars.
2196 else if ( max( o_obj.rows(), 1 ) > 1 )
2197 return 1;
2198 else
2199 return 0;
2200 }
2201
2202 //
2203 // Return the n'th dimension of an object. Dimension 0 is the 1st dimension.
2204 //
2205 static inline int
2206 _dim( const octave_value &o_obj, int dim_idx )
2207 {
2208 if ( dim_idx == 0 )
2209 return max( o_obj.rows(), 0 );
2210 // max is necessary because sometimes
2211 // rows() or columns() return -1 or 0 for
2212 // scalars.
2213 else if ( dim_idx == 1 )
2214 return max( o_obj.columns(), 0 );
2215 else
2216 return 1;
2217 }
2218
2219 //
2220 // The following function converts an array of doubles into some other
2221 // numeric type. Arguments:
2222 // 1) Where to store the result. The type is determined from the type of
2223 // this pointer.
2224 // 2) A vector of doubles to convert.
2225 // 3) The number of doubles.
2226 //
2227 template <class FLOAT>
2228 static inline void
2229 _cvt_double_to( FLOAT *out_arr, double *in_arr, unsigned n_el )
2230 {
2231 while ( n_el-- > 0 )
2232 *out_arr++ = (FLOAT) ( *in_arr++ );
2233 }
2234
2235 template void _cvt_double_to( int *, double *, unsigned );
2236 template void _cvt_double_to( unsigned *, double *, unsigned );
2237 template void _cvt_double_to( long *, double *, unsigned );
2238 template void _cvt_double_to( unsigned long *, double *, unsigned );
2239 template void _cvt_double_to( short *, double *, unsigned );
2240 template void _cvt_double_to( unsigned short *, double *, unsigned );
2241 template void _cvt_double_to( float *, double *, unsigned );
2242 // Instantiate our templates. Octave uses
2243 // manual template instantiation.
2244
2245 //
2246 // Convert an array of some other type into an array of doubles. Arguments:
2247 // 1) The array of objects of other type.
2248 // 2) The output array of doubles.
2249 // 3) The number of elements to convert.
2250 //
2251 template <class FLOAT>
2252 static inline void
2253 _cvt_to_double( FLOAT *arr, double *d_arr, unsigned n_el )
2254 {
2255 while ( n_el-- > 0 )
2256 *d_arr++ = double(*arr++);
2257 }
2258
2259 template void _cvt_to_double( int *, double *, unsigned );
2260 template void _cvt_to_double( unsigned *, double *, unsigned );
2261 template void _cvt_to_double( long *, double *, unsigned );
2262 template void _cvt_to_double( unsigned long *, double *, unsigned );
2263 template void _cvt_to_double( short *, double *, unsigned );
2264 template void _cvt_to_double( unsigned short *, double *, unsigned );
2265 template void _cvt_to_double( float *, double *, unsigned );
2266 // Instantiate our templates. Octave uses
2267 // manual template instantiation.
2268
2269
2270 typedef PLINT ( *defined_func )( PLFLT, PLFLT );
2271 typedef void ( *fill_func )( PLINT, const PLFLT*, const PLFLT* );
2272 typedef void ( *pltr_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2273 typedef void ( *ct_func )( PLFLT, PLFLT, PLFLT *, PLFLT*, PLPointer );
2274 typedef void ( *mapform_func )( PLINT, PLFLT *, PLFLT* );
2275 typedef PLFLT ( *f2eval_func )( PLINT, PLINT, PLPointer );
2276 typedef void ( *label_func )( PLINT, PLFLT, char*, PLINT, PLPointer );
2277
2278
2279 #include <iostream>
2280
2281 octave_function *fcnMapForm;
2282 std::string nameMapForm;
2283
2284 void mapform_octave( PLINT n, PLFLT *x, PLFLT *y )
2285 {
2286 octave_idx_type i;
2287 octave_value_list functionArguments;
2288 octave_value_list retval;
2289
2290 Matrix xin( n, 1 );
2291 Matrix yin( n, 1 );
2292 Matrix xout;
2293 Matrix yout;
2294
2295 for ( i = 0; i < n; i++ )
2296 {
2297 xin( i, 0 ) = x[i];
2298 yin( i, 0 ) = y[i];
2299 }
2300
2301 functionArguments( 0 ) = xin;
2302 functionArguments( 1 ) = yin;
2303
2304 if ( fcnMapForm != NULL )
2305 retval = feval( fcnMapForm, functionArguments, 1 );
2306 else
2307 retval = feval( nameMapForm, functionArguments, 1 );
2308
2309
2310 if ( retval.length() >= 2 )
2311 {
2312 xout = retval( 0 ).matrix_value();
2313 yout = retval( 1 ).matrix_value();
2314
2315 for ( i = 0; i < n; i++ )
2316 {
2317 x[i] = xout( i, 0 );
2318 y[i] = yout( i, 0 );
2319 }
2320 }
2321 }
2322
2323
2324 octave_function *fcnLabelFunc;
2325 std::string nameLabelFunc;
2326
2327 void labelfunc_octave( PLINT axis, PLFLT value, char *label, PLINT length, PLPointer data )
2328 {
2329 int i;
2330 octave_value_list functionArguments;
2331 octave_value_list retval;
2332
2333 Matrix inAxis( 1, 1 );
2334 Matrix inValue( 1, 1 );
2335 inAxis( 0, 0 ) = axis;
2336 inValue( 0, 0 ) = value;
2337
2338 functionArguments( 0 ) = inAxis;
2339 functionArguments( 1 ) = inValue;
2340
2341 if ( fcnLabelFunc != NULL )
2342 retval = feval( fcnLabelFunc, functionArguments, 1 );
2343 else
2344 retval = feval( nameLabelFunc, functionArguments, 1 );
2345
2346 strncpy( label, retval( 0 ).string_value().c_str(), length );
2347 }
2348
2349
2350 octave_function *fcnCoordTrans;
2351 std::string nameCoordTrans;
2352
2353 void ct_octave( PLFLT x, PLFLT y, PLFLT *xt, PLFLT *yt, PLPointer data )
2354 {
2355 octave_idx_type i;
2356 octave_value_list functionArguments;
2357 octave_value_list retval;
2358
2359 Matrix xin( 1, 1 );
2360 Matrix yin( 1, 1 );
2361 Matrix xout;
2362 Matrix yout;
2363
2364 xin( 0, 0 ) = x;
2365 yin( 0, 0 ) = y;
2366
2367 functionArguments( 0 ) = xin;
2368 functionArguments( 1 ) = yin;
2369
2370 if ( fcnCoordTrans != NULL )
2371 retval = feval( fcnCoordTrans, functionArguments, 1 );
2372 else
2373 retval = feval( nameCoordTrans, functionArguments, 1 );
2374
2375
2376 if ( retval.length() >= 2 )
2377 {
2378 xout = retval( 0 ).matrix_value();
2379 yout = retval( 1 ).matrix_value();
2380
2381 *xt = xout( 0, 0 );
2382 *yt = yout( 0, 0 );
2383 }
2384 }
2385
2386
2387 void testppchar( PLINT nlegend, const PLINT *opt_array, const char ** text )
2388 {
2389 PLINT i;
2390 printf( "nlegend =%d\n", nlegend );
2391 for ( i = 0; i < nlegend; i++ )
2392 {
2393 printf( "opt_array[%d] =%d\n", i, opt_array[i] );
2394 printf( "strlen(text[%d]) =%d\n", i, (int) strlen( text[i] ) );
2395 printf( "text[%d] =%s\n", i, text[i] );
2396 }
2397 }
2398
2399
2400 #include <limits.h>
2401 #if !defined(SWIG_NO_LLONG_MAX)
2402 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2403 # define LLONG_MAX __LONG_LONG_MAX__
2404 # define LLONG_MIN (-LLONG_MAX - 1LL)
2405 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2406 # endif
2407 #endif
2408
2409
2410 SWIGINTERN int SWIG_AsVal_long (const octave_value& ov, long* val)
2411 {
2412 if (!ov.is_scalar_type())
2413 return SWIG_TypeError;
2414 if (ov.is_complex_scalar())
2415 return SWIG_TypeError;
2416 if (ov.is_double_type()||ov.is_single_type()) {
2417 double v=ov.double_value();
2418 if (v!=floor(v))
2419 return SWIG_TypeError;
2420 }
2421 if (val)
2422 *val = ov.long_value();
2423 return SWIG_OK;
2424 }
2425
2426
2427 SWIGINTERN int
2428 SWIG_AsVal_int (octave_value obj, int *val)
2429 {
2430 long v;
2431 int res = SWIG_AsVal_long (obj, &v);
2432 if (SWIG_IsOK(res)) {
2433 if ((v < INT_MIN || v > INT_MAX)) {
2434 return SWIG_OverflowError;
2435 } else {
2436 if (val) *val = (int)(v);
2437 }
2438 }
2439 return res;
2440 }
2441
2442
2443 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 )
2444 {
2445 PLGraphicsIn gin;
2446 int status; status = plGetCursor( &gin );
2447 *subwin = gin.subwindow; *state = gin.state; *keysym = gin.keysym; *button = gin.button;
2448 strncpy( string, gin.string, PL_MAXKEY - 1 );
2449 string[PL_MAXKEY - 1] = '\0';
2450
2451 *pX = gin.pX; *pY = gin.pY; *dX = gin.dX; *dY = gin.dY; *wX = gin.wX; *wY = gin.wY;
2452 return status;
2453 }
2454
2455
2456 SWIGINTERN int
2457 SWIG_AsCharPtrAndSize(octave_value ov, char** cptr, size_t* psize, int *alloc)
2458 {
2459 if (ov.is_cell() && ov.rows() == 1 && ov.columns() == 1)
2460 ov = ov.cell_value()(0);
2461 if (!ov.is_string())
2462 return SWIG_TypeError;
2463
2464 std::string str=ov.string_value();
2465 size_t len=str.size();
2466 char* cstr=(char*)str.c_str();
2467 if (alloc) {
2468 *cptr = (char*)(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
2469 *alloc = SWIG_NEWOBJ;
2470 } else if (cptr)
2471 *cptr = cstr;
2472 if (psize)
2473 *psize = len + 1;
2474 return SWIG_OK;
2475 }
2476
2477
2478
2479
2480
2481 SWIGINTERNINLINE octave_value SWIG_From_long (long value)
2482 {
2483 return octave_value(value);
2484 }
2485
2486
2487 SWIGINTERNINLINE octave_value
2488 SWIG_From_int (int value)
2489 {
2490 return SWIG_From_long (value);
2491 }
2492
2493
2494 SWIGINTERNINLINE octave_value SWIG_From_double (double value)
2495 {
2496 return octave_value(value);
2497 }
2498
2499
2500 // Translates relative device coordinates to world coordinates.
2501 static int my_plTranslateCursor( PLFLT *x, PLFLT *y, PLFLT x_in, PLFLT y_in )
2502 {
2503 PLGraphicsIn gin;
2504 int st;
2505 gin.dX = x_in; gin.dY = y_in;
2506 st = plTranslateCursor( &gin );
2507 *x = gin.wX; *y = gin.wY;
2508 return st;
2509 }
2510
2511
2512 SWIGINTERN int SWIG_AsVal_double (const octave_value& ov, double* val)
2513 {
2514 if (!ov.is_scalar_type())
2515 return SWIG_TypeError;
2516 if (ov.is_complex_scalar())
2517 return SWIG_TypeError;
2518 if (val)
2519 *val = ov.double_value();
2520 return SWIG_OK;
2521 }
2522
2523
2524 // Create 1d stripchart
2525
2526 void my_plstripc( PLINT *id, const char *xspec, const char *yspec,
2527 PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
2528 PLFLT xlpos, PLFLT ylpos,
2529 PLBOOL y_ascl, PLBOOL acc,
2530 PLINT colbox, PLINT collab,
2531 const PLINT *colline, const PLINT *styline,
2532 const char *legline1, const char *legline2, const char *legline3, const char *legline4,
2533 const char *labx, const char *laby, const char *labtop )
2534 {
2535 const char *legline[4];
2536 legline[0] = legline1; legline[1] = legline2;
2537 legline[2] = legline3; legline[3] = legline4;
2538 c_plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax,
2539 xlpos, ylpos, y_ascl, acc, colbox, collab, colline, styline, legline,
2540 labx, laby, labtop );
2541 }
2542
2543
2544 // One more hack. As it is not possible (and would not be desirable) to pass
2545 // an Octave function to plcont(), I have defined three plcont():
2546 // plcont uses a defined here xform()
2547 // plcont0 uses pltr0()
2548 // plcont1 uses pltr1()
2549 // plcont2 uses pltr2()
2550 // plcont2p uses pltr2p()
2551 //
2552 // Also, as plplot expect vectorized bidimensional arrays, I provided a
2553 // f2c, which is a #define that does the necessary conversion.
2554 //
2555
2556 void xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data )
2557 {
2558 *tx = *( (PLFLT *) pltr_data + 0 ) * x + *( (PLFLT *) pltr_data + 1 ) * y + *( (PLFLT *) pltr_data + 2 );
2559 *ty = *( (PLFLT *) pltr_data + 3 ) * x + *( (PLFLT *) pltr_data + 4 ) * y + *( (PLFLT *) pltr_data + 5 );
2560 }
2561
2562 // convert from Fortran like arrays (one vector), to C like 2D arrays
2563
2564 #define f2c( f, ff, nx, ny ) \
2565 PLFLT * *ff; \
2566 ff = (PLFLT **) alloca( nx * sizeof ( PLFLT * ) ); \
2567 for ( int i = 0; i < nx; i++ ) { \
2568 ff[i] = (PLFLT *) alloca( ny * sizeof ( PLFLT ) ); \
2569 for ( int j = 0; j < ny; j++ ) \
2570 *( ff[i] + j ) = *( f + nx * j + i );}
2571
2572 // simpler plcont() for use with xform()
2573
2574 void my_plcont( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2575 PLINT ly, const PLFLT *clevel, PLINT nlevel, PLFLT *tr )
2576 {
2577 f2c( f, ff, nx, ny );
2578 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, xform, tr );
2579 }
2580
2581 // plcont() for use with pltr0() NOT TESTED
2582
2583 void my_plcont0( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2584 PLINT ly, const PLFLT *clevel, PLINT nlevel )
2585 {
2586 f2c( f, ff, nx, ny );
2587 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr0, NULL );
2588 }
2589
2590 // plcont() for use with pltr1()
2591
2592 void my_plcont1( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2593 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2594 {
2595 PLcGrid grid1;
2596 grid1.nx = nx; grid1.ny = ny;
2597 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2598 f2c( f, ff, nx, ny );
2599 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr1, &grid1 );
2600 }
2601
2602 // plcont() for use with pltr2()
2603 void my_plcont2( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2604 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2605 {
2606 PLcGrid2 grid2;
2607 f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2608 grid2.nx = nx; grid2.ny = ny;
2609 grid2.xg = xgg; grid2.yg = ygg;
2610 f2c( f, ff, nx, ny );
2611 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2612 }
2613
2614 // plcont() for use with pltr2p()
2615
2616 void my_plcont2p( const PLFLT *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky,
2617 PLINT ly, const PLFLT *clevel, PLINT nlevel, const PLFLT *xg, const PLFLT *yg )
2618 {
2619 PLcGrid2 grid2;
2620 f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2621 grid2.nx = nx; grid2.ny = ny;
2622 grid2.xg = xgg; grid2.yg = ygg;
2623 f2c( f, ff, nx, ny );
2624 c_plcont( (const PLFLT **) ff, nx, ny, kx, lx, ky, ly, clevel, nlevel, pltr2, &grid2 );
2625 }
2626
2627
2628 void my_plgriddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, int npts,
2629 const PLFLT *xg, int nptsx, const PLFLT *yg, int nptsy,
2630 PLFLT *zg, int type, PLFLT data )
2631 {
2632 f2c( zg, zgg, nptsx, nptsy );
2633 plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zgg, type, data );
2634 for ( int i = 0; i < nptsx; i++ )
2635 for ( int j = 0; j < nptsy; j++ )
2636 *( zg + nptsx * j + i ) = zgg[i][j];
2637 }
2638
2639
2640 // Plots a mesh representation of the function z[x][y].
2641
2642 void my_plmesh( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt )
2643 {
2644 f2c( z, zz, nx, ny );
2645 c_plmesh( x, y, (const PLFLT **) zz, nx, ny, opt );
2646 }
2647
2648 // Plots a mesh representation of the function z[x][y] with contour
2649
2650 void my_plmeshc( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
2651 {
2652 f2c( z, zz, nx, ny );
2653 c_plmeshc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2654 }
2655
2656
2657 // Plots a 3-d representation of the function z[x][y].
2658 void my_plot3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2659 PLINT nx, PLINT ny, PLINT opt, PLINT side )
2660 {
2661 f2c( z, zz, nx, ny )
2662 c_plot3d( x, y, (const PLFLT **) zz, nx, ny, opt, side );
2663 }
2664
2665 // Plots a 3-d representation of the function z[x][y] with contour
2666 void my_plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2667 PLINT nx, PLINT ny, PLINT opt,
2668 const PLFLT *clevel, PLINT nlevel )
2669 {
2670 f2c( z, zz, nx, ny )
2671 c_plot3dc( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2672 }
2673
2674
2675 void my_plsurf3d( const PLFLT *x, const PLFLT *y, const PLFLT *z,
2676 PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel )
2677 {
2678 f2c( z, zz, nx, ny )
2679 c_plsurf3d( x, y, (const PLFLT **) zz, nx, ny, opt, clevel, nlevel );
2680 }
2681
2682
2683 // The same as in plcont. I have hardcoded the first function pointer
2684 // to plfill(). The second function pointer will use the same convention
2685 // as in plcont().
2686 //
2687
2688 // the simpler plshade()
2689 void my_plshade( const PLFLT *a, PLINT nx, PLINT ny, const PLFLT *defined,
2690 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2691 PLFLT shade_min, PLFLT shade_max,
2692 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2693 PLINT min_color, PLINT min_width,
2694 PLINT max_color, PLINT max_width,
2695 PLINT rectangular, PLFLT *tr )
2696 {
2697 f2c( a, aa, nx, ny );
2698 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2699 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2700 min_color, min_width, max_color, max_width,
2701 plfill, rectangular, xform, tr );
2702 }
2703
2704 // plshade() for use with pltr1
2705 void my_plshade1( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
2706 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2707 PLFLT shade_min, PLFLT shade_max,
2708 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2709 PLINT min_color, PLINT min_width,
2710 PLINT max_color, PLINT max_width,
2711 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2712 {
2713 PLcGrid grid1;
2714 grid1.nx = nx; grid1.ny = ny;
2715 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2716 f2c( a, aa, nx, ny );
2717 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2718 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2719 min_color, min_width, max_color, max_width,
2720 plfill, rectangular, pltr1, &grid1 );
2721 }
2722
2723 // plshade() for use with pltr2
2724 void my_plshade2( const PLFLT *a, PLINT nx, PLINT ny, const char *defined,
2725 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2726 PLFLT shade_min, PLFLT shade_max,
2727 PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
2728 PLINT min_color, PLINT min_width,
2729 PLINT max_color, PLINT max_width,
2730 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2731 {
2732 PLcGrid2 grid2;
2733 f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2734 grid2.nx = nx; grid2.ny = ny;
2735 grid2.xg = xgg; grid2.yg = ygg;
2736 f2c( a, aa, nx, ny );
2737 c_plshade( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2738 shade_min, shade_max, sh_cmap, sh_color, sh_width,
2739 min_color, min_width, max_color, max_width,
2740 plfill, rectangular, pltr2, &grid2 );
2741 }
2742
2743
2744
2745 void my_plshades( const PLFLT *a, PLINT nx, PLINT ny,
2746 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2747 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2748 PLINT cont_color, PLINT cont_width,
2749 PLINT rectangular )
2750 {
2751 f2c( a, aa, nx, ny );
2752 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2753 clevel, nlevel, fill_width, cont_color, cont_width,
2754 plfill, rectangular, NULL, NULL );
2755 }
2756
2757 void my_plshadesx( const PLFLT *a, PLINT nx, PLINT ny,
2758 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2759 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2760 PLINT cont_color, PLINT cont_width,
2761 PLINT rectangular, PLFLT *tr )
2762 {
2763 f2c( a, aa, nx, ny );
2764 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2765 clevel, nlevel, fill_width, cont_color, cont_width,
2766 plfill, rectangular, xform, tr );
2767 }
2768
2769 void my_plshades1( const PLFLT *a, PLINT nx, PLINT ny,
2770 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2771 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2772 PLINT cont_color, PLINT cont_width,
2773 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2774 {
2775 PLcGrid grid1;
2776 grid1.nx = nx; grid1.ny = ny;
2777 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2778
2779 f2c( a, aa, nx, ny );
2780 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2781 clevel, nlevel, fill_width, cont_color, cont_width,
2782 plfill, rectangular, pltr1, &grid1 );
2783 }
2784
2785 void my_plshades2( const PLFLT *a, PLINT nx, PLINT ny,
2786 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2787 const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
2788 PLINT cont_color, PLINT cont_width,
2789 PLINT rectangular, const PLFLT *xg, const PLFLT *yg )
2790 {
2791 PLcGrid2 grid2;
2792 f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2793 grid2.nx = nx; grid2.ny = ny;
2794 grid2.xg = xgg; grid2.yg = ygg;
2795 f2c( a, aa, nx, ny );
2796 c_plshades( (const PLFLT **) aa, nx, ny, NULL, left, right, bottom, top,
2797 clevel, nlevel, fill_width, cont_color, cont_width,
2798 plfill, rectangular, pltr2, &grid2 );
2799 }
2800
2801
2802 // Plot an array of vector arrows - uses the same function pointer
2803 // convention as plcont
2804
2805 void my_plvect( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, PLFLT *tr )
2806 {
2807 f2c( u, uu, nx, ny );
2808 f2c( v, vv, nx, ny );
2809 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, xform, tr );
2810 }
2811
2812 // plvect() for use with pltr1
2813 void my_plvect1( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
2814 {
2815 PLcGrid grid1;
2816 grid1.nx = nx; grid1.ny = ny;
2817 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2818 f2c( u, uu, nx, ny );
2819 f2c( v, vv, nx, ny );
2820 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr1, &grid1 );
2821 }
2822
2823 // plvect() for use with pltr2
2824 void my_plvect2( const PLFLT *u, const PLFLT *v, PLINT nx, PLINT ny, PLFLT scale, const PLFLT *xg, const PLFLT *yg )
2825 {
2826 PLcGrid2 grid2;
2827 f2c( xg, xgg, nx, ny ); f2c( yg, ygg, nx, ny );
2828 grid2.nx = nx; grid2.ny = ny;
2829 grid2.xg = xgg; grid2.yg = ygg;
2830 f2c( u, uu, nx, ny );
2831 f2c( v, vv, nx, ny );
2832 c_plvect( (const PLFLT **) uu, (const PLFLT **) vv, nx, ny, scale, pltr2, &grid2 );
2833 }
2834
2835
2836 // Plot an image with distortion - uses the same function pointer
2837 void my_plimage( const PLFLT *a, PLINT nx, PLINT ny,
2838 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2839 PLFLT zmin, PLFLT zmax,
2840 PLFLT dxmin, PLFLT dxmax, PLFLT dymin, PLFLT dymax )
2841 {
2842 f2c( a, aa, nx, ny );
2843 plimage( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, dxmin, dxmax, dymin, dymax );
2844 }
2845
2846 // Plot an image with distortion - uses the same function pointer
2847 // convention as plcont
2848 void my_plimagefr( const PLFLT *a, PLINT nx, PLINT ny,
2849 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2850 PLFLT zmin, PLFLT zmax,
2851 PLFLT valuemin, PLFLT valuemax )
2852 {
2853 f2c( a, aa, nx, ny );
2854 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, NULL, NULL );
2855 }
2856
2857 void my_plimagefrx( const PLFLT *a, PLINT nx, PLINT ny,
2858 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2859 PLFLT zmin, PLFLT zmax,
2860 PLFLT valuemin, PLFLT valuemax, PLFLT *tr )
2861 {
2862 f2c( a, aa, nx, ny );
2863 plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, xform, tr );
2864 }
2865
2866 // plimagefr() for use with pltr1
2867 void my_plimagefr1( const PLFLT *a, PLINT nx, PLINT ny,
2868 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2869 PLFLT zmin, PLFLT zmax,
2870 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
2871 {
2872 PLcGrid grid1;
2873 grid1.nx = nx + 1; grid1.ny = ny + 1;
2874 grid1.xg = (PLFLT *) xg; grid1.yg = (PLFLT *) yg;
2875 f2c( a, aa, nx, ny );
2876 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr1, &grid1 );
2877 }
2878
2879 // plimagefr() for use with pltr2
2880 void my_plimagefr2( const PLFLT *a, PLINT nx, PLINT ny,
2881 PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2882 PLFLT zmin, PLFLT zmax,
2883 PLFLT valuemin, PLFLT valuemax, const PLFLT *xg, const PLFLT *yg )
2884 {
2885 PLcGrid2 grid2;
2886 f2c( xg, xgg, ( nx + 1 ), ( ny + 1 ) ); f2c( yg, ygg, ( nx + 1 ), ( ny + 1 ) );
2887 grid2.nx = nx + 1; grid2.ny = ny + 1;
2888 grid2.xg = xgg; grid2.yg = ygg;
2889 f2c( a, aa, nx, ny );
2890 c_plimagefr( (const PLFLT **) aa, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, valuemin, valuemax, pltr2, &grid2 );
2891 }
2892
2893
2894
2895 void my_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
2896 PLINT opt, PLINT position, PLFLT x, PLFLT y,
2897 PLFLT x_length, PLFLT y_length,
2898 PLINT bg_color, PLINT bb_color, PLINT bb_style,
2899 PLFLT low_cap_color, PLFLT high_cap_color,
2900 PLINT cont_color, PLFLT cont_width,
2901 PLINT n_labels, const PLINT *label_opts, const char **label,
2902 PLINT n_axes, const char ** axis_opts,
2903 const PLFLT *ticks, const PLINT *sub_ticks,
2904 const PLINT *n_values, const PLFLT *a )
2905 {
2906 PLINT nx, ny, i;
2907 nx = n_axes;
2908 ny = -1;
2909 for ( i = 0; i < nx; i++ )
2910 if ( n_values[i] > ny )
2911 ny = n_values[i];
2912 f2c( a, aa, nx, ny );
2913 c_plcolorbar( p_colorbar_width, p_colorbar_height,
2914 opt, position, x, y,
2915 x_length, y_length,
2916 bg_color, bb_color, bb_style,
2917 low_cap_color, high_cap_color,
2918 cont_color, cont_width,
2919 n_labels, label_opts, label,
2920 n_axes, axis_opts,
2921 ticks, sub_ticks,
2922 n_values, aa );
2923 }
2924
2925
2926
2927 SWIGINTERN int SWIG_AsVal_unsigned_SS_long (const octave_value& ov, unsigned long* val)
2928 {
2929 if (!ov.is_scalar_type())
2930 return SWIG_TypeError;
2931 if (ov.is_complex_scalar())
2932 return SWIG_TypeError;
2933 if (ov.is_double_type()||ov.is_single_type()) {
2934 double v=ov.double_value();
2935 if (v<0)
2936 return SWIG_OverflowError;
2937 if (v!=floor(v))
2938 return SWIG_TypeError;
2939 }
2940 if (ov.is_int8_type()||ov.is_int16_type()||
2941 ov.is_int32_type()) {
2942 long v=ov.long_value();
2943 if (v<0)
2944 return SWIG_OverflowError;
2945 }
2946 if (ov.is_int64_type()) {
2947 long long v=ov.int64_scalar_value().value();
2948 if (v<0)
2949 return SWIG_OverflowError;
2950 }
2951 if (val)
2952 *val = ov.ulong_value();
2953 return SWIG_OK;
2954 }
2955
2956
2957 SWIGINTERN int
2958 SWIG_AsVal_unsigned_SS_int (octave_value obj, unsigned int *val)
2959 {
2960 unsigned long v;
2961 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2962 if (SWIG_IsOK(res)) {
2963 if ((v > UINT_MAX)) {
2964 return SWIG_OverflowError;
2965 } else {
2966 if (val) *val = (unsigned int)(v);
2967 }
2968 }
2969 return res;
2970 }
2971
2972
2973 SWIGINTERNINLINE octave_value SWIG_From_unsigned_SS_long (unsigned long value)
2974 {
2975 return octave_value(value);
2976 }
2977
2978
2979 SWIGINTERNINLINE octave_value
2980 SWIG_From_unsigned_SS_int (unsigned int value)
2981 {
2982 return SWIG_From_unsigned_SS_long (value);
2983 }
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsCharArray(octave_value obj, char *val, size_t size)
2988 {
2989 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
2990 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
2991 if (SWIG_IsOK(res)) {
2992 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
2993 if (csize <= size) {
2994 if (val) {
2995 if (csize) memcpy(val, cptr, csize*sizeof(char));
2996 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
2997 }
2998 if (alloc == SWIG_NEWOBJ) {
2999 delete[] cptr;
3000 res = SWIG_DelNewMask(res);
3001 }
3002 return res;
3003 }
3004 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3005 }
3006 return SWIG_TypeError;
3007 }
3008
3009
3010 SWIGINTERN swig_type_info*
3011 SWIG_pchar_descriptor(void)
3012 {
3013 static int init = 0;
3014 static swig_type_info* info = 0;
3015 if (!init) {
3016 info = SWIG_TypeQuery("_p_char");
3017 init = 1;
3018 }
3019 return info;
3020 }
3021
3022
3023 SWIGINTERNINLINE octave_value
3024 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3025 {
3026 return std::string(carray,carray+size);
3027 }
3028
3029
3030 SWIGINTERN int
3031 SWIG_AsVal_char (octave_value obj, char *val)
3032 {
3033 int res = SWIG_AsCharArray(obj, val, 1);
3034 if (!SWIG_IsOK(res)) {
3035 long v;
3036 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3037 if (SWIG_IsOK(res)) {
3038 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3039 if (val) *val = (char)(v);
3040 } else {
3041 res = SWIG_OverflowError;
3042 }
3043 }
3044 }
3045 return res;
3046 }
3047
3048 const char* _wrap_plsvpa_texinfo = "-*- texinfo -*-\n\
3049 Specify viewport in absolute coordinates \n\
3050 \n\
3051 DESCRIPTION:\n\
3052 \n\
3053 Alternate routine to plvpor for setting up the viewport. This routine\n\
3054 should be used only if the viewport is required to have a definite\n\
3055 size in millimeters. The routine plgspa is useful for finding out the\n\
3056 size of the current subpage. \n\
3057 \n\
3058 Redacted form: plsvpa(xmin, xmax, ymin, ymax)\n\
3059 \n\
3060 This function is used in example 10. \n\
3061 \n\
3062 \n\
3063 \n\
3064 SYNOPSIS:\n\
3065 \n\
3066 plsvpa(xmin, xmax, ymin, ymax)\n\
3067 \n\
3068 ARGUMENTS:\n\
3069 \n\
3070 xmin (PLFLT, input) : The distance of the left-hand edge of the\n\
3071 viewport from the left-hand edge of the subpage in millimeters. \n\
3072 \n\
3073 xmax (PLFLT, input) : The distance of the right-hand edge of the\n\
3074 viewport from the left-hand edge of the subpage in millimeters. \n\
3075 \n\
3076 ymin (PLFLT, input) : The distance of the bottom edge of the\n\
3077 viewport from the bottom edge of the subpage in millimeters. \n\
3078 \n\
3079 ymax (PLFLT, input) : The distance of the top edge of the viewport\n\
3080 from the bottom edge of the subpage in millimeters. \n\
3081 ";
3082 const char* _wrap_plmtex3_texinfo = "-*- texinfo -*-\n\
3083 Write text relative to viewport boundaries in 3D plots. \n\
3084 \n\
3085 DESCRIPTION:\n\
3086 \n\
3087 Writes text at a specified position relative to the viewport\n\
3088 boundaries. Text may be written inside or outside the viewport, but\n\
3089 is clipped at the subpage boundaries. The reference point of a string\n\
3090 lies along a line passing through the string at half the height of a\n\
3091 capital letter. The position of the reference point along this line\n\
3092 is determined by just, and the position of the reference point\n\
3093 relative to the viewport is set by disp and pos. \n\
3094 \n\
3095 Redacted form: plmtex3(side, disp, pos, just, text)\n\
3096 \n\
3097 This function is used in example 28. \n\
3098 \n\
3099 \n\
3100 \n\
3101 SYNOPSIS:\n\
3102 \n\
3103 plmtex3(side, disp, pos, just, text)\n\
3104 \n\
3105 ARGUMENTS:\n\
3106 \n\
3107 side (const char *, input) : Specifies the side of the viewport\n\
3108 along which the text is to be written. The string should contain\n\
3109 one or more of the following characters: [xyz][ps][v]. Only one\n\
3110 label is drawn at a time, i.e. xyp will only label the X axis, not\n\
3111 both the X and Y axes. x: Label the X axis. \n\
3112 y: Label the Y axis. \n\
3113 z: Label the Z axis. \n\
3114 p: Label the primary axis. For Z this is the leftmost Z axis.\n\
3115 For X it is the axis that starts at y-min. For Y it is the\n\
3116 axis that starts at x-min. \n\
3117 s: Label the secondary axis. \n\
3118 v: Draw the text perpendicular to the axis. \n\
3119 \n\
3120 \n\
3121 disp (PLFLT, input) : Position of the reference point of string,\n\
3122 measured outwards from the specified viewport edge in units of the\n\
3123 current character height. Use negative disp to write within the\n\
3124 viewport. \n\
3125 \n\
3126 pos (PLFLT, input) : Position of the reference point of string\n\
3127 along the specified edge, expressed as a fraction of the length of\n\
3128 the edge. \n\
3129 \n\
3130 just (PLFLT, input) : Specifies the position of the string relative\n\
3131 to its reference point. If just=0., the reference point is at the\n\
3132 left and if just=1., it is at the right of the string. Other\n\
3133 values of just give intermediate justifications. \n\
3134 \n\
3135 text (const char *, input) : The string to be written out. \n\
3136 ";
3137 const char* _wrap_plscmap1a_texinfo = "-*- texinfo -*-\n\
3138 Set color map1 colors using 8-bit RGB values and double alpha values. \n\
3139 \n\
3140 DESCRIPTION:\n\
3141 \n\
3142 Set color map1 colors using 8-bit RGB values (see the PLplot\n\
3143 documentation) and double alpha values. This also sets the number of\n\
3144 colors.\n\
3145 \n\
3146 This function is used in example 31. \n\
3147 \n\
3148 \n\
3149 \n\
3150 SYNOPSIS:\n\
3151 \n\
3152 plscmap1a(r, g, b, a, ncol1)\n\
3153 \n\
3154 ARGUMENTS:\n\
3155 \n\
3156 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3157 integers (0-255) representing the degree of red in the color. \n\
3158 \n\
3159 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3160 integers (0-255) representing the degree of green in the color. \n\
3161 \n\
3162 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3163 integers (0-255) representing the degree of blue in the color. \n\
3164 \n\
3165 a (PLFLT *, input) : Pointer to array with set of double values\n\
3166 (0.0-1.0) representing the alpha value of the color. \n\
3167 \n\
3168 ncol1 (PLINT, input) : Number of items in the r, g, b, and a\n\
3169 arrays. \n\
3170 ";
3171 const char* _wrap_plvsta_texinfo = "-*- texinfo -*-\n\
3172 Select standard viewport \n\
3173 \n\
3174 DESCRIPTION:\n\
3175 \n\
3176 Sets up a standard viewport, leaving a left-hand margin of seven\n\
3177 character heights, and four character heights around the other three\n\
3178 sides. \n\
3179 \n\
3180 Redacted form: plvsta()\n\
3181 \n\
3182 This function is used in examples 1,12,14,17,25,29. \n\
3183 \n\
3184 \n\
3185 \n\
3186 SYNOPSIS:\n\
3187 \n\
3188 plvsta()\n\
3189 ";
3190 const char* _wrap_plgra_texinfo = "-*- texinfo -*-\n\
3191 Switch to graphics screen \n\
3192 \n\
3193 DESCRIPTION:\n\
3194 \n\
3195 Sets an interactive device to graphics mode, used in conjunction with\n\
3196 pltext to allow graphics and text to be interspersed. On a device\n\
3197 which supports separate text and graphics windows, this command causes\n\
3198 control to be switched to the graphics window. If already in graphics\n\
3199 mode, this command is ignored. It is also ignored on devices which\n\
3200 only support a single window or use a different method for shifting\n\
3201 focus. See also pltext. \n\
3202 \n\
3203 Redacted form: plgra()\n\
3204 \n\
3205 This function is used in example 1. \n\
3206 \n\
3207 \n\
3208 \n\
3209 SYNOPSIS:\n\
3210 \n\
3211 plgra()\n\
3212 ";
3213 const char* _wrap_plscol0a_texinfo = "-*- texinfo -*-\n\
3214 Set a given color from color map0 by 8 bit RGB value and double alpha value. \n\
3215 \n\
3216 DESCRIPTION:\n\
3217 \n\
3218 Set a given color by 8-bit RGB value and double alpha value for color \n\
3219 map0 (see the PLplot documentation). Overwrites the previous color\n\
3220 value for the given index and, thus, does not result in any\n\
3221 additional allocation of space for colors. \n\
3222 \n\
3223 This function is used in example 30. \n\
3224 \n\
3225 \n\
3226 \n\
3227 SYNOPSIS:\n\
3228 \n\
3229 plscol0a(icol0, r, g, b, a)\n\
3230 \n\
3231 ARGUMENTS:\n\
3232 \n\
3233 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
3234 number of colors (which is set by default, by plscmap0n, or even\n\
3235 by plscmap0). \n\
3236 \n\
3237 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3238 degree of red in the color. \n\
3239 \n\
3240 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3241 degree of green in the color. \n\
3242 \n\
3243 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
3244 degree of blue in the color. \n\
3245 \n\
3246 a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n\
3247 value of the color. \n\
3248 ";
3249 const char* _wrap_plsyax_texinfo = "-*- texinfo -*-\n\
3250 Set y axis parameters \n\
3251 \n\
3252 DESCRIPTION:\n\
3253 \n\
3254 Identical to plsxax, except that arguments are flags for y axis. See\n\
3255 the description of plsxax for more detail. \n\
3256 \n\
3257 Redacted form: plsyax(digmax, digits)\n\
3258 \n\
3259 This function is used in examples 1,14,31. \n\
3260 \n\
3261 \n\
3262 \n\
3263 SYNOPSIS:\n\
3264 \n\
3265 plsyax(digmax, digits)\n\
3266 \n\
3267 ARGUMENTS:\n\
3268 \n\
3269 digmax (PLINT, input) : Variable to set the maximum number of\n\
3270 digits for the y axis. If nonzero, the printed label will be\n\
3271 switched to a floating point representation when the number of\n\
3272 digits exceeds digmax. \n\
3273 \n\
3274 digits (PLINT, input) : Field digits value. Currently, changing\n\
3275 its value here has no effect since it is set only by plbox or\n\
3276 plbox3. However, the user may obtain its value after a call to\n\
3277 either of these functions by calling plgyax. \n\
3278 ";
3279 const char* _wrap_plgcol0_texinfo = "-*- texinfo -*-\n\
3280 Returns 8-bit RGB values for given color from color map0 \n\
3281 \n\
3282 DESCRIPTION:\n\
3283 \n\
3284 Returns 8-bit RGB values (0-255) for given color from color map0 (see\n\
3285 the PLplot documentation).\tValues are negative if an invalid color id\n\
3286 is given. \n\
3287 \n\
3288 Redacted form: plgcol0(icol0, r, g, b)\n\
3289 \n\
3290 This function is used in example 2. \n\
3291 \n\
3292 \n\
3293 \n\
3294 SYNOPSIS:\n\
3295 \n\
3296 plgcol0(icol0, r, g, b)\n\
3297 \n\
3298 ARGUMENTS:\n\
3299 \n\
3300 icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3301 \n\
3302 r (PLINT *, output) : Pointer to 8-bit red value. \n\
3303 \n\
3304 g (PLINT *, output) : Pointer to 8-bit green value. \n\
3305 \n\
3306 b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3307 ";
3308 const char* _wrap_plseed_texinfo = "-*- texinfo -*-\n\
3309 Set seed for internal random number generator. \n\
3310 \n\
3311 DESCRIPTION:\n\
3312 \n\
3313 Set the seed for the internal random number generator. See plrandd for\n\
3314 further details. \n\
3315 \n\
3316 Redacted form: plseed(seed)\n\
3317 \n\
3318 This function is used in example 21. \n\
3319 \n\
3320 \n\
3321 \n\
3322 SYNOPSIS:\n\
3323 \n\
3324 plseed(seed)\n\
3325 \n\
3326 ARGUMENTS:\n\
3327 \n\
3328 seed (unsigned int, input) : Seed for random number generator. \n\
3329 ";
3330 const char* _wrap_plgfnam_texinfo = "-*- texinfo -*-\n\
3331 Get output file name \n\
3332 \n\
3333 DESCRIPTION:\n\
3334 \n\
3335 Gets the current output file name, if applicable. \n\
3336 \n\
3337 Redacted form: plgfnam(fnam)\n\
3338 \n\
3339 This function is used in example 31. \n\
3340 \n\
3341 \n\
3342 \n\
3343 SYNOPSIS:\n\
3344 \n\
3345 plgfnam(fnam)\n\
3346 \n\
3347 ARGUMENTS:\n\
3348 \n\
3349 fnam (char *, output) : Pointer to file name string (a preallocated\n\
3350 string of 80 characters or more). \n\
3351 ";
3352 const char* _wrap_plwind_texinfo = "-*- texinfo -*-\n\
3353 Specify world coordinates of viewport boundaries \n\
3354 \n\
3355 DESCRIPTION:\n\
3356 \n\
3357 Sets up the world coordinates of the edges of the viewport. \n\
3358 \n\
3359 Redacted form: plwind(xmin, xmax, ymin, ymax)\n\
3360 \n\
3361 This function is used in examples 1,2,4,6-12,14-16,18,21,23-27,29,31. \n\
3362 \n\
3363 \n\
3364 \n\
3365 SYNOPSIS:\n\
3366 \n\
3367 plwind(xmin, xmax, ymin, ymax)\n\
3368 \n\
3369 ARGUMENTS:\n\
3370 \n\
3371 xmin (PLFLT, input) : The world x coordinate of the left-hand edge\n\
3372 of the viewport. \n\
3373 \n\
3374 xmax (PLFLT, input) : The world x coordinate of the right-hand edge\n\
3375 of the viewport. \n\
3376 \n\
3377 ymin (PLFLT, input) : The world y coordinate of the bottom edge of\n\
3378 the viewport. \n\
3379 \n\
3380 ymax (PLFLT, input) : The world y coordinate of the top edge of the\n\
3381 viewport. \n\
3382 ";
3383 const char* _wrap_plscmap1l_texinfo = "-*- texinfo -*-\n\
3384 Set color map1 colors using a piece-wise linear relationship \n\
3385 \n\
3386 DESCRIPTION:\n\
3387 \n\
3388 Set color map1 colors using a piece-wise linear relationship between\n\
3389 position in the color map (from 0 to 1) and position in HLS or RGB\n\
3390 color space (see the PLplot documentation). May be called at any\n\
3391 time. \n\
3392 \n\
3393 The idea here is to specify a number of control points that define the\n\
3394 mapping between palette 1 input positions (intensities) and HLS (or\n\
3395 RGB). Between these points, linear interpolation is used which gives\n\
3396 a smooth variation of color with input position. Any number of\n\
3397 control points may be specified, located at arbitrary positions,\n\
3398 although typically 2 - 4 are enough. Another way of stating this is\n\
3399 that we are traversing a given number of lines through HLS (or RGB)\n\
3400 space as we move through color map1 entries. The control points at\n\
3401 the minimum and maximum position (0 and 1) must always be specified. \n\
3402 By adding more control points you can get more variation. One good\n\
3403 technique for plotting functions that vary about some expected average\n\
3404 is to use an additional 2 control points in the center (position ~=\n\
3405 0.5) that are the same lightness as the background (typically white\n\
3406 for paper output, black for crt), and same hue as the boundary control\n\
3407 points. This allows the highs and lows to be very easily\n\
3408 distinguished. \n\
3409 \n\
3410 Each control point must specify the position in color map1 as well as\n\
3411 three coordinates in HLS or RGB space. The first point must\n\
3412 correspond to position = 0, and the last to position = 1. \n\
3413 \n\
3414 The default behaviour is for the hue to be linearly interpolated \n\
3415 between the control points. Since the hue lies in the range [0, 360]\n\
3416 this corresponds to interpolation around the \"front\" of the color\n\
3417 wheel (red<->green<->blue<->red). If alt_hue_path[i] is true, then an\n\
3418 alternative interpolation is used between control points i and i+1. If\n\
3419 hue[i+1]-hue[i] > 0 then interpolation is between\thue[i] and\n\
3420 hue[i+1] - 360, otherwise between hue[i] and hue[i+1] + 360. You can\n\
3421 consider this as interpolation around the \"back\" or \"reverse\" of the\n\
3422 color wheel. Specifying alt_hue_path=NULL is equivalent to setting\n\
3423 alt_hue_path[] = false for\tevery control point. \n\
3424 \n\
3425 Examples of interpolation Huealt_hue_pathcolor scheme[120\n\
3426 240]falsegreen-cyan-blue[240 120]falseblue-cyan-green[120\n\
3427 240]truegreen-yellow-red-magenta-blue[240\n\
3428 120]trueblue-magenta-red-yellow-green\n\
3429 \n\
3430 Bounds on coordinatesRGBR[0, 1]magnitudeRGBG[0, 1]magnitudeRGBB[0,\n\
3431 1]magnitudeHLShue[0, 360]degreesHLSlightness[0,\n\
3432 1]magnitudeHLSsaturation[0, 1]magnitude\n\
3433 \n\
3434 Redacted form: plscmap1l(itype, pos, coord1, coord2, coord3,\n\
3435 alt_hue_path)\n\
3436 \n\
3437 This function is used in examples 8,11,12,15,20,21. \n\
3438 \n\
3439 \n\
3440 \n\
3441 SYNOPSIS:\n\
3442 \n\
3443 plscmap1l(itype, npts, pos, coord1, coord2, coord3, alt_hue_path)\n\
3444 \n\
3445 ARGUMENTS:\n\
3446 \n\
3447 itype (PLBOOL, input) : true: RGB, false: HLS. \n\
3448 \n\
3449 npts (PLINT, input) : number of control points \n\
3450 \n\
3451 pos (PLFLT *, input) : position for each control point (between 0.0\n\
3452 and 1.0, in ascending order) \n\
3453 \n\
3454 coord1 (PLFLT *, input) : first coordinate (H or R) for each\n\
3455 control point \n\
3456 \n\
3457 coord2 (PLFLT *, input) : second coordinate (L or G) for each\n\
3458 control point \n\
3459 \n\
3460 coord3 (PLFLT *, input) : third coordinate (S or B) for each\n\
3461 control point \n\
3462 \n\
3463 alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n\
3464 flag for each control point. (alt_hue_path[i] refers to the\n\
3465 interpolation interval between the i and i + 1 control points). \n\
3466 ";
3467 const char* _wrap_plspause_texinfo = "-*- texinfo -*-\n\
3468 Set the pause (on end-of-page) status \n\
3469 \n\
3470 DESCRIPTION:\n\
3471 \n\
3472 Set the pause (on end-of-page) status. \n\
3473 \n\
3474 Redacted form: plspause(pause)\n\
3475 \n\
3476 This function is in examples 14,20. \n\
3477 \n\
3478 \n\
3479 \n\
3480 SYNOPSIS:\n\
3481 \n\
3482 plspause(pause)\n\
3483 \n\
3484 ARGUMENTS:\n\
3485 \n\
3486 pause (PLBOOL, input) : If pause is true there will be a pause on\n\
3487 end-of-page for those drivers which support this. Otherwise there\n\
3488 is no pause. \n\
3489 ";
3490 const char* _wrap_pllegend_texinfo = "-*- texinfo -*-\n\
3491 Plot legend using discretely annotated filled boxes, lines, and/or lines of symbols \n\
3492 \n\
3493 DESCRIPTION:\n\
3494 \n\
3495 Routine for creating a discrete plot legend with a plotted filled box,\n\
3496 line, and/or line of symbols for each annotated legend entry. (See\n\
3497 plcolorbar for similar functionality for creating continuous color\n\
3498 bars.) The arguments of pllegend provide control over the location\n\
3499 and size of the legend as well as the location and characteristics of\n\
3500 the elements (most of which are optional) within that legend. The\n\
3501 resulting legend is clipped at the boundaries of the current subpage. \n\
3502 (N.B. the adopted coordinate system used for some of the parameters is\n\
3503 defined in the documentation of the position parameter.) \n\
3504 \n\
3505 Redacted form: pllegend(p_legend_width, p_legend_height, opt,\n\
3506 position, x, y, plot_width, bg_color, bb_color, bb_style, nrow,\n\
3507 ncolumn, opt_array, text_offset, text_scale, text_spacing,\n\
3508 test_justification, text_colors, text, box_colors, box_patterns,\n\
3509 box_scales, box_line_widths, line_colors, line_styles, line_widths,\n\
3510 symbol_colors, symbol_scales, symbol_numbers, symbols)\n\
3511 \n\
3512 This function is used in examples 4, 26, and 33. \n\
3513 \n\
3514 \n\
3515 \n\
3516 SYNOPSIS:\n\
3517 \n\
3518 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\
3519 \n\
3520 ARGUMENTS:\n\
3521 \n\
3522 p_legend_width (PLFLT *, output) : Pointer to a location which\n\
3523 contains (after the call) the legend width in adopted coordinates.\n\
3524 This quantity is calculated from plot_width, text_offset, ncolumn\n\
3525 (possibly modified inside the routine depending on nlegend and\n\
3526 nrow), and the length (calculated internally) of the longest text\n\
3527 string. \n\
3528 \n\
3529 p_legend_height (PLFLT *, output) : Pointer to a location which\n\
3530 contains (after the call) the legend height in adopted\n\
3531 coordinates. This quantity is calculated from text_scale,\n\
3532 text_spacing, and nrow (possibly modified inside the routine\n\
3533 depending on nlegend and nrow). \n\
3534 \n\
3535 opt (PLINT, input) : opt contains bits controlling the overall\n\
3536 legend. If the PL_LEGEND_TEXT_LEFT bit is set, put the text area\n\
3537 on the left of the legend and the plotted area on the right.\n\
3538 Otherwise, put the text area on the right of the legend and the\n\
3539 plotted area on the left. If the PL_LEGEND_BACKGROUND bit is set,\n\
3540 plot a (semi-transparent) background for the legend. If the\n\
3541 PL_LEGEND_BOUNDING_BOX bit is set, plot a bounding box for the\n\
3542 legend. If the PL_LEGEND_ROW_MAJOR bit is set and (both of the\n\
3543 possibly internally transformed) nrow > 1 and ncolumn > 1, then\n\
3544 plot the resulting array of legend entries in row-major order.\n\
3545 Otherwise, plot the legend entries in column-major order. \n\
3546 \n\
3547 position (PLINT, input) : position contains bits which control the\n\
3548 overall position of the legend and the definition of the adopted\n\
3549 coordinates used for positions just like what is done for the\n\
3550 position argument for plcolorbar. However, note that the defaults\n\
3551 for the position bits (see below) are different than the\n\
3552 plcolorbar case. The combination of the PL_POSITION_LEFT,\n\
3553 PL_POSITION_RIGHT, PL_POSITION_TOP, PL_POSITION_BOTTOM,\n\
3554 PL_POSITION_INSIDE, and PL_POSITION_OUTSIDE bits specifies one of\n\
3555 the 16 possible standard positions (the 4 corners and centers of\n\
3556 the 4 sides for both the inside and outside cases) of the legend\n\
3557 relative to the adopted coordinate system. The corner positions\n\
3558 are specified by the appropriate combination of two of the\n\
3559 PL_POSITION_LEFT, PL_POSITION_RIGHT, PL_POSITION_TOP, and\n\
3560 PL_POSITION_BOTTOM bits while the sides are specified by a single\n\
3561 value of one of those bits. The adopted coordinates are\n\
3562 normalized viewport coordinates if the PL_POSITION_VIEWPORT bit is\n\
3563 set or normalized subpage coordinates if the PL_POSITION_SUBPAGE\n\
3564 bit is set. Default position bits: If none of PL_POSITION_LEFT,\n\
3565 PL_POSITION_RIGHT, PL_POSITION_TOP, or PL_POSITION_BOTTOM are set,\n\
3566 then use the combination of PL_POSITION_RIGHT and PL_POSITION_TOP.\n\
3567 If neither of PL_POSITION_INSIDE or PL_POSITION_OUTSIDE is set,\n\
3568 use PL_POSITION_INSIDE. If neither of PL_POSITION_VIEWPORT or\n\
3569 PL_POSITION_SUBPAGE is set, use PL_POSITION_VIEWPORT. \n\
3570 \n\
3571 x (PLFLT, input) : X offset of the legend position in adopted\n\
3572 coordinates from the specified standard position of the legend.\n\
3573 For positive x, the direction of motion away from the standard\n\
3574 position is inward/outward from the standard corner positions or\n\
3575 standard left or right positions if the\n\
3576 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3577 For the standard top or bottom positions, the direction of motion\n\
3578 is toward positive X. \n\
3579 \n\
3580 y (PLFLT, input) : Y offset of the legend position in adopted\n\
3581 coordinates from the specified standard position of the legend.\n\
3582 For positive y, the direction of motion away from the standard\n\
3583 position is inward/outward from the standard corner positions or\n\
3584 standard top or bottom positions if the\n\
3585 PL_POSITION_INSIDE/PL_POSITION_OUTSIDE bit is set in position. \n\
3586 For the standard left or right positions, the direction of motion\n\
3587 is toward positive Y. \n\
3588 \n\
3589 plot_width (PLFLT, input) : Horizontal width in adopted coordinates\n\
3590 of the plot area (where the colored boxes, lines, and/or lines of\n\
3591 symbols are drawn) of the legend. \n\
3592 \n\
3593 bg_color (PLINT, input) : The cmap0 color of the background for the\n\
3594 legend (PL_LEGEND_BACKGROUND). \n\
3595 \n\
3596 bb_color (PLINT, input) : The cmap0 color of the bounding-box line\n\
3597 for the legend (PL_LEGEND_BOUNDING_BOX). \n\
3598 \n\
3599 bb_style (PLINT, input) : The pllsty style number for the\n\
3600 bounding-box line for the legend (PL_LEGEND_BACKGROUND). \n\
3601 \n\
3602 nrow (PLINT, input) : The cmap0 index of the background color for\n\
3603 the legend (PL_LEGEND_BACKGROUND). \n\
3604 \n\
3605 ncolumn (PLINT, input) : The cmap0 index of the background color\n\
3606 for the legend (PL_LEGEND_BACKGROUND). \n\
3607 \n\
3608 nlegend (PLINT, input) : Number of legend entries. N.B. The total\n\
3609 vertical height of the legend in adopted coordinates is calculated\n\
3610 internally from nlegend, text_scale (see below), and text_spacing\n\
3611 (see below). \n\
3612 \n\
3613 opt_array (const PLINT *, input) : Array of nlegend values of\n\
3614 options to control each individual plotted area corresponding to a\n\
3615 legend entry. If the \n\
3616 PL_LEGEND_NONE bit is set, then nothing is plotted in the plotted\n\
3617 area. If the \n\
3618 PL_LEGEND_COLOR_BOX, \n\
3619 PL_LEGEND_LINE, and/or \n\
3620 PL_LEGEND_SYMBOL bits are set, the area corresponding to a legend\n\
3621 entry is plotted with a colored box; a line; and/or a line of\n\
3622 symbols. \n\
3623 \n\
3624 text_offset (PLFLT, input) : Offset of the text area from the plot\n\
3625 area in units of character width. N.B. The total horizontal\n\
3626 width of the legend in adopted coordinates is calculated\n\
3627 internally from \n\
3628 plot_width (see above), \n\
3629 text_offset, and length (calculated internally) of the longest text\n\
3630 string. \n\
3631 \n\
3632 text_scale (PLFLT, input) : Character height scale for text\n\
3633 annotations. N.B. The total vertical height of the legend in\n\
3634 adopted coordinates is calculated internally from \n\
3635 nlegend (see above), \n\
3636 text_scale, and \n\
3637 text_spacing (see below). \n\
3638 \n\
3639 text_spacing (PLFLT, input) : Vertical spacing in units of the\n\
3640 character height from one legend entry to the next. N.B. The\n\
3641 total vertical height of the legend in adopted coordinates is\n\
3642 calculated internally from \n\
3643 nlegend (see above), \n\
3644 text_scale (see above), and \n\
3645 text_spacing. \n\
3646 \n\
3647 text_justification (PLFLT, input) : Justification parameter used\n\
3648 for text justification. The most common values of\n\
3649 text_justification are 0., 0.5, or 1. corresponding to a text that\n\
3650 is left justified, centred, or right justified within the text\n\
3651 area, but other values are allowed as well. \n\
3652 \n\
3653 text_colors (const PLINT *, input) : Array of nlegend cmap0 text\n\
3654 colors. \n\
3655 \n\
3656 text (const char *const *, input) : Array of nlegend text string\n\
3657 annotations. \n\
3658 \n\
3659 box_colors (const PLINT *, input) : Array of nlegend cmap0 colors\n\
3660 for the discrete colored boxes (\n\
3661 PL_LEGEND_COLOR_BOX). \n\
3662 \n\
3663 box_patterns (const PLINT *, input) : Array of nlegend patterns\n\
3664 (plpsty indices) for the discrete colored boxes (\n\
3665 PL_LEGEND_COLOR_BOX). \n\
3666 \n\
3667 box_scales (const PLFLT *, input) : Array of nlegend scales (units\n\
3668 of fraction of character height) for the height of the discrete\n\
3669 colored boxes (\n\
3670 PL_LEGEND_COLOR_BOX). \n\
3671 \n\
3672 box_line_widths (const PLFLT *, input) : Array of nlegend line\n\
3673 widths for the patterns specified by box_patterns (\n\
3674 PL_LEGEND_COLOR_BOX). \n\
3675 \n\
3676 line_colors (const PLINT *, input) : Array of nlegend cmap0 line\n\
3677 colors (\n\
3678 PL_LEGEND_LINE). \n\
3679 \n\
3680 line_styles (const PLINT *, input) : Array of nlegend line styles\n\
3681 (plsty indices) (\n\
3682 PL_LEGEND_LINE). \n\
3683 \n\
3684 line_widths (const PLFLT *, input) : Array of nlegend line widths (\n\
3685 PL_LEGEND_LINE). \n\
3686 \n\
3687 symbol_colors (const PLINT *, input) : Array of nlegend cmap0\n\
3688 symbol colors (\n\
3689 PL_LEGEND_SYMBOL). \n\
3690 \n\
3691 symbol_scales (const PLFLT *, input) : Array of nlegend scale\n\
3692 values for the symbol height (\n\
3693 PL_LEGEND_SYMBOL). \n\
3694 \n\
3695 symbol_numbers (const PLINT *, input) : Array of nlegend numbers of\n\
3696 symbols to be drawn across the width of the plotted area (\n\
3697 PL_LEGEND_SYMBOL). \n\
3698 \n\
3699 symbols (const char *const *, input) : Array of nlegend symbols\n\
3700 (plpoin indices) (\n\
3701 PL_LEGEND_SYMBOL). \n\
3702 ";
3703 const char* _wrap_plscmap1n_texinfo = "-*- texinfo -*-\n\
3704 Set number of colors in color map1 \n\
3705 \n\
3706 DESCRIPTION:\n\
3707 \n\
3708 Set number of colors in color map1, (re-)allocate color map1, and set\n\
3709 default values if this is the first allocation (see the PLplot\n\
3710 documentation). \n\
3711 \n\
3712 Redacted form: plscmap1n(ncol1)\n\
3713 \n\
3714 This function is used in examples 8,11,20,21. \n\
3715 \n\
3716 \n\
3717 \n\
3718 SYNOPSIS:\n\
3719 \n\
3720 plscmap1n(ncol1)\n\
3721 \n\
3722 ARGUMENTS:\n\
3723 \n\
3724 ncol1 (PLINT, input) : Number of colors that will be allocated in\n\
3725 the map1 palette. If this number is zero or less, then the value\n\
3726 from the previous call to plscmap1n is used and if there is no\n\
3727 previous call, then a default value is used. \n\
3728 ";
3729 const char* _wrap_plgcol0a_texinfo = "-*- texinfo -*-\n\
3730 Returns 8-bit RGB values and double alpha value for given color from color map0. \n\
3731 \n\
3732 DESCRIPTION:\n\
3733 \n\
3734 Returns 8-bit RGB values (0-255) and double alpha value (0.0 - 1.0)\n\
3735 for given color from color map0 (see the PLplot documentation). \n\
3736 Values are negative if an invalid color id is given. \n\
3737 \n\
3738 This function is used in example 30. \n\
3739 \n\
3740 \n\
3741 \n\
3742 SYNOPSIS:\n\
3743 \n\
3744 plgcol0a(icol0, r, g, b, a)\n\
3745 \n\
3746 ARGUMENTS:\n\
3747 \n\
3748 icol0 (PLINT, input) : Index of desired cmap0 color. \n\
3749 \n\
3750 r (PLINT *, output) : Pointer to 8-bit red value. \n\
3751 \n\
3752 g (PLINT *, output) : Pointer to 8-bit green value. \n\
3753 \n\
3754 b (PLINT *, output) : Pointer to 8-bit blue value. \n\
3755 \n\
3756 a (PLFLT *, output) : Pointer to PLFLT alpha value. \n\
3757 ";
3758 const char* _wrap_plreplot_texinfo = "-*- texinfo -*-\n\
3759 Replays contents of plot buffer to current device/file \n\
3760 \n\
3761 DESCRIPTION:\n\
3762 \n\
3763 Replays contents of plot buffer to current device/file. \n\
3764 \n\
3765 Redacted form: plreplot()\n\
3766 \n\
3767 This function is used in example 1,20. \n\
3768 \n\
3769 \n\
3770 \n\
3771 SYNOPSIS:\n\
3772 \n\
3773 plreplot()\n\
3774 ";
3775 const char* _wrap_pllab_texinfo = "-*- texinfo -*-\n\
3776 Simple routine to write labels \n\
3777 \n\
3778 DESCRIPTION:\n\
3779 \n\
3780 Routine for writing simple labels. Use plmtex for more complex labels. \n\
3781 \n\
3782 Redacted form: pllab(xlabel, ylabel, tlabel)\n\
3783 \n\
3784 This function is used in examples 1,5,9,12,14-16,20-22,29. \n\
3785 \n\
3786 \n\
3787 \n\
3788 SYNOPSIS:\n\
3789 \n\
3790 pllab(xlabel, ylabel, tlabel)\n\
3791 \n\
3792 ARGUMENTS:\n\
3793 \n\
3794 xlabel (const char *, input) : Label for horizontal axis. \n\
3795 \n\
3796 ylabel (const char *, input) : Label for vertical axis. \n\
3797 \n\
3798 tlabel (const char *, input) : Title of graph. \n\
3799 ";
3800 const char* _wrap_plsdidev_texinfo = "-*- texinfo -*-\n\
3801 Set parameters that define current device-space window \n\
3802 \n\
3803 DESCRIPTION:\n\
3804 \n\
3805 Set relative margin width, aspect ratio, and relative justification\n\
3806 that define current device-space window. If you want to just use the\n\
3807 previous value for any of these, just pass in the magic value\n\
3808 PL_NOTSET. It is unlikely that one should ever need to change the\n\
3809 aspect ratio but it\'s in there for completeness. If plsdidev is not\n\
3810 called the default values of mar, jx, and jy are all 0. aspect is set\n\
3811 to a device-specific value. \n\
3812 \n\
3813 Redacted form: plsdidev(mar, aspect, jx, jy)\n\
3814 \n\
3815 This function is used in example 31. \n\
3816 \n\
3817 \n\
3818 \n\
3819 SYNOPSIS:\n\
3820 \n\
3821 plsdidev(mar, aspect, jx, jy)\n\
3822 \n\
3823 ARGUMENTS:\n\
3824 \n\
3825 mar (PLFLT, input) : Relative margin width. \n\
3826 \n\
3827 aspect (PLFLT, input) : Aspect ratio. \n\
3828 \n\
3829 jx (PLFLT, input) : Relative justification in x. Value must lie in\n\
3830 the range -0.5 to 0.5. \n\
3831 \n\
3832 jy (PLFLT, input) : Relative justification in y. Value must lie in\n\
3833 the range -0.5 to 0.5. \n\
3834 ";
3835 const char* _wrap_plbop_texinfo = "-*- texinfo -*-\n\
3836 Begin a new page\n\
3837 \n\
3838 DESCRIPTION:\n\
3839 \n\
3840 Begins a new page.\tFor a file driver, the output file is opened if\n\
3841 necessary.\tAdvancing the page via pleop and plbop is useful when a\n\
3842 page break is desired at a particular point when plotting to subpages.\n\
3843 Another use for pleop and plbop is when plotting pages to different\n\
3844 files, since you can manually set the file name by calling plsfnam\n\
3845 after the call to pleop. (In fact some drivers may only support a\n\
3846 single page per file, making this a necessity.) One way to handle\n\
3847 this case automatically is to page advance via pladv, but enable\n\
3848 familying (see plsfam) with a small limit on the file size so that a\n\
3849 new family member file will be created on each page break. \n\
3850 \n\
3851 Redacted form: plbop()\n\
3852 \n\
3853 This function is used in examples 2,20. \n\
3854 \n\
3855 \n\
3856 \n\
3857 SYNOPSIS:\n\
3858 \n\
3859 plbop()\n\
3860 ";
3861 const char* _wrap_plscmap0_texinfo = "-*- texinfo -*-\n\
3862 Set color map0 colors by 8-bit RGB values \n\
3863 \n\
3864 DESCRIPTION:\n\
3865 \n\
3866 Set color map0 colors using 8-bit RGB values (see the PLplot\n\
3867 documentation). This sets the entire color map -- only as many colors\n\
3868 as specified will be allocated. \n\
3869 \n\
3870 Redacted form: plscmap0(r, g, b, ncol0)\n\
3871 \n\
3872 This function is used in examples 2,24. \n\
3873 \n\
3874 \n\
3875 \n\
3876 SYNOPSIS:\n\
3877 \n\
3878 plscmap0(r, g, b, ncol0)\n\
3879 \n\
3880 ARGUMENTS:\n\
3881 \n\
3882 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3883 integers (0-255) representing the degree of red in the color. \n\
3884 \n\
3885 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3886 integers (0-255) representing the degree of green in the color. \n\
3887 \n\
3888 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3889 integers (0-255) representing the degree of blue in the color. \n\
3890 \n\
3891 ncol0 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
3892 ";
3893 const char* _wrap_plssub_texinfo = "-*- texinfo -*-\n\
3894 Set the number of subpages in x and y \n\
3895 \n\
3896 DESCRIPTION:\n\
3897 \n\
3898 Set the number of subpages in x and y. \n\
3899 \n\
3900 Redacted form: plssub(nx, ny)\n\
3901 \n\
3902 This function is examples 1,2,14,21,25,27. \n\
3903 \n\
3904 \n\
3905 \n\
3906 SYNOPSIS:\n\
3907 \n\
3908 plssub(nx, ny)\n\
3909 \n\
3910 ARGUMENTS:\n\
3911 \n\
3912 nx (PLINT, input) : Number of windows in x direction (i.e., number\n\
3913 of window columns). \n\
3914 \n\
3915 ny (PLINT, input) : Number of windows in y direction (i.e., number\n\
3916 of window rows). \n\
3917 ";
3918 const char* _wrap_plstransform_texinfo = "-*- texinfo -*-\n\
3919 Set a global coordinate transform function \n\
3920 \n\
3921 DESCRIPTION:\n\
3922 \n\
3923 This function can be used to define a coordinate transformation which\n\
3924 affects all elements drawn within the current plot window.\tThe\n\
3925 transformation function is similar to that provided for the plmap and\n\
3926 plmeridians functions. The data parameter may be used to pass extra\n\
3927 data to transform_fun. \n\
3928 \n\
3929 Redacted form: General: plstransform(transform_fun, data)\n\
3930 \n\
3931 \n\
3932 This function is used in examples 19 and 22. \n\
3933 \n\
3934 \n\
3935 \n\
3936 SYNOPSIS:\n\
3937 \n\
3938 plstransform(transform_fun, data)\n\
3939 \n\
3940 ARGUMENTS:\n\
3941 \n\
3942 transform_fun (void (*) (PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer) ,\n\
3943 input) : Pointer to a function that defines a transformation\n\
3944 from the input (x, y) coordinate to a new plot world coordinate. A\n\
3945 NULL pointer means that no transform is applied. \n\
3946 \n\
3947 data (PLPointer, input) : Optional extra data for \n\
3948 transform_fun. \n\
3949 ";
3950 const char* _wrap_plscmap1_texinfo = "-*- texinfo -*-\n\
3951 Set color map1 colors using 8-bit RGB values \n\
3952 \n\
3953 DESCRIPTION:\n\
3954 \n\
3955 Set color map1 colors using 8-bit RGB values (see the PLplot\n\
3956 documentation). This also sets the number of colors. \n\
3957 \n\
3958 Redacted form: plscmap1(r, g, b, ncol1)\n\
3959 \n\
3960 This function is used in example 31. \n\
3961 \n\
3962 \n\
3963 \n\
3964 SYNOPSIS:\n\
3965 \n\
3966 plscmap1(r, g, b, ncol1)\n\
3967 \n\
3968 ARGUMENTS:\n\
3969 \n\
3970 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3971 integers (0-255) representing the degree of red in the color. \n\
3972 \n\
3973 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3974 integers (0-255) representing the degree of green in the color. \n\
3975 \n\
3976 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
3977 integers (0-255) representing the degree of blue in the color. \n\
3978 \n\
3979 ncol1 (PLINT, input) : Number of items in the r, g, and b arrays. \n\
3980 ";
3981 const char* _wrap_plsmin_texinfo = "-*- texinfo -*-\n\
3982 Set length of minor ticks \n\
3983 \n\
3984 DESCRIPTION:\n\
3985 \n\
3986 This sets up the length of the minor ticks and the length of the\n\
3987 terminals on error bars. The actual length is the product of the\n\
3988 default length and a scaling factor as for character height. \n\
3989 \n\
3990 Redacted form: plsmin(def, scale)\n\
3991 \n\
3992 This function is used in example 29. \n\
3993 \n\
3994 \n\
3995 \n\
3996 SYNOPSIS:\n\
3997 \n\
3998 plsmin(def, scale)\n\
3999 \n\
4000 ARGUMENTS:\n\
4001 \n\
4002 def (PLFLT, input) : The default length of a minor tick in\n\
4003 millimeters, should be set to zero if the default length is to\n\
4004 remain unchanged. \n\
4005 \n\
4006 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4007 actual tick length. \n\
4008 ";
4009 const char* _wrap_plschr_texinfo = "-*- texinfo -*-\n\
4010 Set character size \n\
4011 \n\
4012 DESCRIPTION:\n\
4013 \n\
4014 This sets up the size of all subsequent characters drawn. The actual\n\
4015 height of a character is the product of the default character size and\n\
4016 a scaling factor. \n\
4017 \n\
4018 Redacted form: plschr(def, scale)\n\
4019 \n\
4020 This function is used in example 2,13,23,24. \n\
4021 \n\
4022 \n\
4023 \n\
4024 SYNOPSIS:\n\
4025 \n\
4026 plschr(def, scale)\n\
4027 \n\
4028 ARGUMENTS:\n\
4029 \n\
4030 def (PLFLT, input) : The default height of a character in\n\
4031 millimeters, should be set to zero if the default height is to\n\
4032 remain unchanged. \n\
4033 \n\
4034 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
4035 actual character height. \n\
4036 ";
4037 const char* _wrap_plinit_texinfo = "-*- texinfo -*-\n\
4038 Initialize PLplot \n\
4039 \n\
4040 DESCRIPTION:\n\
4041 \n\
4042 Initializing the plotting package.\tThe program prompts for the device\n\
4043 keyword or number of the desired output device. Hitting a RETURN in\n\
4044 response to the prompt is the same as selecting the first device. \n\
4045 plinit will issue no prompt if either the device was specified\n\
4046 previously (via command line flag, the plsetopt function, or the\n\
4047 plsdev function), or if only one device is enabled when PLplot is\n\
4048 installed.\tIf subpages have been specified, the output device is\n\
4049 divided into nx by ny subpages, each of which may be used\n\
4050 independently. If plinit is called again during a program, the\n\
4051 previously opened file will be closed. The subroutine pladv is used\n\
4052 to advance from one subpage to the next. \n\
4053 \n\
4054 Redacted form: plinit()\n\
4055 \n\
4056 This function is used in all of the examples. \n\
4057 \n\
4058 \n\
4059 \n\
4060 SYNOPSIS:\n\
4061 \n\
4062 plinit()\n\
4063 ";
4064 const char* _wrap_plbox_texinfo = "-*- texinfo -*-\n\
4065 Draw a box with axes, etc\n\
4066 \n\
4067 DESCRIPTION:\n\
4068 \n\
4069 Draws a box around the currently defined viewport, and labels it with\n\
4070 world coordinate values appropriate to the window.\tThus plbox should\n\
4071 only be called after defining both viewport and window. The character\n\
4072 strings xopt and yopt specify how the box should be drawn as described\n\
4073 below. If ticks and/or subticks are to be drawn for a particular\n\
4074 axis, the tick intervals and number of subintervals may be specified\n\
4075 explicitly, or they may be defaulted by setting the appropriate\n\
4076 arguments to zero. \n\
4077 \n\
4078 Redacted form: General: plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4079 \t Perl/PDL: plbox(xtick, nxsub, ytick, nysub, xopt, yopt)\n\
4080 \n\
4081 \n\
4082 This function is used in examples 1,2,4,6,6-12,14-18,21,23-26,29. \n\
4083 \n\
4084 \n\
4085 \n\
4086 SYNOPSIS:\n\
4087 \n\
4088 plbox(xopt, xtick, nxsub, yopt, ytick, nysub)\n\
4089 \n\
4090 ARGUMENTS:\n\
4091 \n\
4092 xopt (const char *, input) : Pointer to character string specifying\n\
4093 options for horizontal axis. The string can include any\n\
4094 combination of the following letters (upper or lower case) in any\n\
4095 order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
4096 is vertical line (x=0). \n\
4097 b: Draws bottom (X) or left (Y) edge of frame. \n\
4098 c: Draws top (X) or right (Y) edge of frame. \n\
4099 d: Plot labels as date / time. Values are assumed to be\n\
4100 seconds since the epoch (as used by gmtime). \n\
4101 f: Always use fixed point numeric labels. \n\
4102 g: Draws a grid at the major tick interval. \n\
4103 h: Draws a grid at the minor tick interval. \n\
4104 i: Inverts tick marks, so they are drawn outwards, rather than\n\
4105 inwards. \n\
4106 l: Labels axis logarithmically. This only affects the labels,\n\
4107 not the data, and so it is necessary to compute the logarithms\n\
4108 of data points before passing them to any of the drawing\n\
4109 routines. \n\
4110 m: Writes numeric labels at major tick intervals in the\n\
4111 unconventional location (above box for X, right of box for Y). \n\
4112 n: Writes numeric labels at major tick intervals in the\n\
4113 conventional location (below box for X, left of box for Y). \n\
4114 o: Use custom labelling function to generate axis label text. \n\
4115 The custom labelling function can be defined with the\n\
4116 plslabelfunc command. \n\
4117 s: Enables subticks between major ticks, only valid if t is\n\
4118 also specified. \n\
4119 t: Draws major ticks. \n\
4120 u: Exactly like \"b\" except don\'t draw edge line. \n\
4121 w: Exactly like \"c\" except don\'t draw edge line. \n\
4122 x: Exactly like \"t\" (including the side effect of the\n\
4123 numerical labels for the major ticks) except exclude drawing\n\
4124 the major and minor tick marks. \n\
4125 \n\
4126 \n\
4127 xtick (PLFLT, input) : World coordinate interval between major\n\
4128 ticks on the x axis. If it is set to zero, PLplot automatically\n\
4129 generates a suitable tick interval. \n\
4130 \n\
4131 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
4132 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4133 generates a suitable minor tick interval. \n\
4134 \n\
4135 yopt (const char *, input) : Pointer to character string specifying\n\
4136 options for vertical axis. The string can include any combination\n\
4137 of the letters defined above for xopt, and in addition may\n\
4138 contain: v: Write numeric labels for vertical axis parallel to the\n\
4139 base of the graph, rather than parallel to the axis. \n\
4140 \n\
4141 \n\
4142 ytick (PLFLT, input) : World coordinate interval between major\n\
4143 ticks on the y axis. If it is set to zero, PLplot automatically\n\
4144 generates a suitable tick interval. \n\
4145 \n\
4146 nysub (PLINT, input) : Number of subintervals between major y axis\n\
4147 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
4148 generates a suitable minor tick interval. \n\
4149 ";
4150 const char* _wrap_plgdidev_texinfo = "-*- texinfo -*-\n\
4151 Get parameters that define current device-space window \n\
4152 \n\
4153 DESCRIPTION:\n\
4154 \n\
4155 Get relative margin width, aspect ratio, and relative justification\n\
4156 that define current device-space window. If plsdidev has not been\n\
4157 called the default values pointed to by p_mar, p_aspect, p_jx, and\n\
4158 p_jy will all be 0. \n\
4159 \n\
4160 Redacted form: plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4161 \n\
4162 This function is used in example 31. \n\
4163 \n\
4164 \n\
4165 \n\
4166 SYNOPSIS:\n\
4167 \n\
4168 plgdidev(p_mar, p_aspect, p_jx, p_jy)\n\
4169 \n\
4170 ARGUMENTS:\n\
4171 \n\
4172 p_mar (PLFLT *, output) : Pointer to relative margin width. \n\
4173 \n\
4174 p_aspect (PLFLT *, output) : Pointer to aspect ratio. \n\
4175 \n\
4176 p_jx (PLFLT *, output) : Pointer to relative justification in x. \n\
4177 \n\
4178 p_jy (PLFLT *, output) : Pointer to relative justification in y. \n\
4179 ";
4180 const char* _wrap_plstring_texinfo = "-*- texinfo -*-\n\
4181 Plot a glyph at the specified points \n\
4182 \n\
4183 DESCRIPTION:\n\
4184 \n\
4185 Plot a glyph at the specified points. (Supersedes plpoin and plsym\n\
4186 because many[!] more glyphs are accessible with plstring.) The glyph\n\
4187 is specified with a PLplot user string. Note that the user string is\n\
4188 not actually limited to one glyph so it is possible (but not normally\n\
4189 useful) to plot more than one glyph at the specified points with this\n\
4190 function. As with plmtex and plptex, the user string can contain FCI\n\
4191 escapes to determine the font, UTF-8 code to determine the glyph or\n\
4192 else PLplot escapes for Hershey or unicode text to determine the\n\
4193 glyph. \n\
4194 \n\
4195 Redacted form: plstring(x, y, string)\n\
4196 \n\
4197 This function is used in examples 4, 21 and 26. \n\
4198 \n\
4199 \n\
4200 \n\
4201 SYNOPSIS:\n\
4202 \n\
4203 plstring(n, x, y, string)\n\
4204 \n\
4205 ARGUMENTS:\n\
4206 \n\
4207 n (PLINT, input) : Number of points in the x and y arrays. \n\
4208 \n\
4209 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
4210 points. \n\
4211 \n\
4212 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
4213 points. \n\
4214 \n\
4215 string (const char *, input) : PLplot user string corresponding to\n\
4216 the glyph to be plotted at each of the n points. \n\
4217 ";
4218 const char* _wrap_plenv0_texinfo = "-*- texinfo -*-\n\
4219 Same as plenv but if in multiplot mode does not advance the subpage, instead clears it. \n\
4220 \n\
4221 DESCRIPTION:\n\
4222 \n\
4223 Sets up plotter environment for simple graphs by calling pladv and\n\
4224 setting up viewport and window to sensible default values.\tplenv0\n\
4225 leaves enough room around most graphs for axis labels and a title.\n\
4226 When these defaults are not suitable, use the individual routines\n\
4227 plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
4228 defining the window, and plbox for drawing the box. \n\
4229 \n\
4230 Redacted form: plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4231 \n\
4232 This function is used in example 21. \n\
4233 \n\
4234 \n\
4235 \n\
4236 SYNOPSIS:\n\
4237 \n\
4238 plenv0(xmin, xmax, ymin, ymax, just, axis)\n\
4239 \n\
4240 ARGUMENTS:\n\
4241 \n\
4242 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
4243 world coordinates). \n\
4244 \n\
4245 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
4246 world coordinates). \n\
4247 \n\
4248 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
4249 coordinates). \n\
4250 \n\
4251 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
4252 coordinates). \n\
4253 \n\
4254 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
4255 scales will not be set, the user must set up the scale before\n\
4256 calling plenv0 using plsvpa, plvasp or other. \n\
4257 0: the x and y axes are scaled independently to use as much of\n\
4258 the screen as possible. \n\
4259 1: the scales of the x and y axes are made equal. \n\
4260 2: the axis of the x and y axes are made equal, and the plot\n\
4261 box will be square. \n\
4262 \n\
4263 \n\
4264 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
4265 -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
4266 -1: draw box only. \n\
4267 0: draw box, ticks, and numeric tick labels. \n\
4268 1: also draw coordinate axes at x=0 and y=0. \n\
4269 2: also draw a grid at major tick positions in both\n\
4270 coordinates. \n\
4271 3: also draw a grid at minor tick positions in both\n\
4272 coordinates. \n\
4273 10: same as 0 except logarithmic x tick marks. (The x data\n\
4274 have to be converted to logarithms separately.) \n\
4275 11: same as 1 except logarithmic x tick marks. (The x data\n\
4276 have to be converted to logarithms separately.) \n\
4277 12: same as 2 except logarithmic x tick marks. (The x data\n\
4278 have to be converted to logarithms separately.) \n\
4279 13: same as 3 except logarithmic x tick marks. (The x data\n\
4280 have to be converted to logarithms separately.) \n\
4281 20: same as 0 except logarithmic y tick marks. (The y data\n\
4282 have to be converted to logarithms separately.) \n\
4283 21: same as 1 except logarithmic y tick marks. (The y data\n\
4284 have to be converted to logarithms separately.) \n\
4285 22: same as 2 except logarithmic y tick marks. (The y data\n\
4286 have to be converted to logarithms separately.) \n\
4287 23: same as 3 except logarithmic y tick marks. (The y data\n\
4288 have to be converted to logarithms separately.) \n\
4289 30: same as 0 except logarithmic x and y tick marks. (The x\n\
4290 and y data have to be converted to logarithms separately.) \n\
4291 31: same as 1 except logarithmic x and y tick marks. (The x\n\
4292 and y data have to be converted to logarithms separately.) \n\
4293 32: same as 2 except logarithmic x and y tick marks. (The x\n\
4294 and y data have to be converted to logarithms separately.) \n\
4295 33: same as 3 except logarithmic x and y tick marks. (The x\n\
4296 and y data have to be converted to logarithms separately.) \n\
4297 40: same as 0 except date / time x labels. \n\
4298 41: same as 1 except date / time x labels. \n\
4299 42: same as 2 except date / time x labels. \n\
4300 43: same as 3 except date / time x labels. \n\
4301 50: same as 0 except date / time y labels. \n\
4302 51: same as 1 except date / time y labels. \n\
4303 52: same as 2 except date / time y labels. \n\
4304 53: same as 3 except date / time y labels. \n\
4305 60: same as 0 except date / time x and y labels. \n\
4306 61: same as 1 except date / time x and y labels. \n\
4307 62: same as 2 except date / time x and y labels. \n\
4308 63: same as 3 except date / time x and y labels. \n\
4309 70: same as 0 except custom x and y labels. \n\
4310 71: same as 1 except custom x and y labels. \n\
4311 72: same as 2 except custom x and y labels. \n\
4312 73: same as 3 except custom x and y labels. \n\
4313 ";
4314 const char* _wrap_plw3d_texinfo = "-*- texinfo -*-\n\
4315 Set up window for 3-d plotting \n\
4316 \n\
4317 DESCRIPTION:\n\
4318 \n\
4319 Sets up a window for a three-dimensional surface plot within the\n\
4320 currently defined two-dimensional window. The enclosing box for the\n\
4321 surface plot defined by xmin, xmax, ymin, ymax, zmin and zmax in\n\
4322 user-coordinate space is mapped into a box of world coordinate size\n\
4323 basex by basey by height so that xmin maps to -\n\
4324 basex/2, xmax maps to basex/2, ymin maps to -\n\
4325 basey/2, ymax maps to basey/2, zmin maps to 0 and zmax maps to height.\n\
4326 The resulting world-coordinate box is then viewed by an observer at\n\
4327 altitude alt and azimuth az. This routine must be called before\n\
4328 plbox3 or plot3d. For a more complete description of\n\
4329 three-dimensional plotting see the PLplot documentation. \n\
4330 \n\
4331 Redacted form: plw3d(basex, basey, height, xmin, xmax, ymin, ymax,\n\
4332 zmin, zmax, alt, az)\n\
4333 \n\
4334 This function is examples 8,11,18,21. \n\
4335 \n\
4336 \n\
4337 \n\
4338 SYNOPSIS:\n\
4339 \n\
4340 plw3d(basex, basey, height, xmin, xmax, ymin, ymax, zmin, zmax, alt, az)\n\
4341 \n\
4342 ARGUMENTS:\n\
4343 \n\
4344 basex (PLFLT, input) : The x coordinate size of the\n\
4345 world-coordinate box. \n\
4346 \n\
4347 basey (PLFLT, input) : The y coordinate size of the\n\
4348 world-coordinate box. \n\
4349 \n\
4350 height (PLFLT, input) : The z coordinate size of the\n\
4351 world-coordinate box. \n\
4352 \n\
4353 xmin (PLFLT, input) : The minimum user x coordinate value. \n\
4354 \n\
4355 xmax (PLFLT, input) : The maximum user x coordinate value. \n\
4356 \n\
4357 ymin (PLFLT, input) : The minimum user y coordinate value. \n\
4358 \n\
4359 ymax (PLFLT, input) : The maximum user y coordinate value. \n\
4360 \n\
4361 zmin (PLFLT, input) : The minimum user z coordinate value. \n\
4362 \n\
4363 zmax (PLFLT, input) : The maximum user z coordinate value. \n\
4364 \n\
4365 alt (PLFLT, input) : The viewing altitude in degrees above the XY\n\
4366 plane. \n\
4367 \n\
4368 az (PLFLT, input) : The viewing azimuth in degrees. When az=0, the\n\
4369 observer is looking face onto the ZX plane, and as az is\n\
4370 increased, the observer moves clockwise around the box when viewed\n\
4371 from above the XY plane. \n\
4372 ";
4373 const char* _wrap_plfill_texinfo = "-*- texinfo -*-\n\
4374 Draw filled polygon \n\
4375 \n\
4376 DESCRIPTION:\n\
4377 \n\
4378 Fills the polygon defined by the n points (\n\
4379 x[i], \n\
4380 y[i]) using the pattern defined by plpsty or plpat. The default fill\n\
4381 style is a solid fill. The routine will automatically close the\n\
4382 polygon between the last and first vertices. If multiple closed\n\
4383 polygons are passed in x and y then plfill will fill in between them. \n\
4384 \n\
4385 Redacted form: plfill(x,y)\n\
4386 \n\
4387 This function is used in examples 12,13,15,16,21,24,25. \n\
4388 \n\
4389 \n\
4390 \n\
4391 SYNOPSIS:\n\
4392 \n\
4393 plfill(n, x, y)\n\
4394 \n\
4395 ARGUMENTS:\n\
4396 \n\
4397 n (PLINT, input) : Number of vertices in polygon. \n\
4398 \n\
4399 x (PLFLT *, input) : Pointer to array with x coordinates of\n\
4400 vertices. \n\
4401 \n\
4402 y (PLFLT *, input) : Pointer to array with y coordinates of\n\
4403 vertices. \n\
4404 ";
4405 const char* _wrap_plmtex_texinfo = "-*- texinfo -*-\n\
4406 Write text relative to viewport boundaries \n\
4407 \n\
4408 DESCRIPTION:\n\
4409 \n\
4410 Writes text at a specified position relative to the viewport\n\
4411 boundaries. Text may be written inside or outside the viewport, but\n\
4412 is clipped at the subpage boundaries. The reference point of a string\n\
4413 lies along a line passing through the string at half the height of a\n\
4414 capital letter. The position of the reference point along this line\n\
4415 is determined by just, and the position of the reference point\n\
4416 relative to the viewport is set by disp and pos. \n\
4417 \n\
4418 Redacted form: General: plmtex(side, disp, pos, just, text)\n\
4419 \t Perl/PDL: plmtex(disp, pos, just, side, text)\n\
4420 \n\
4421 \n\
4422 This function is used in examples 3,4,6-8,11,12,14,18,23,26. \n\
4423 \n\
4424 \n\
4425 \n\
4426 SYNOPSIS:\n\
4427 \n\
4428 plmtex(side, disp, pos, just, text)\n\
4429 \n\
4430 ARGUMENTS:\n\
4431 \n\
4432 side (const char *, input) : Specifies the side of the viewport\n\
4433 along which the text is to be written. The string must be one of:\n\
4434 b: Bottom of viewport, text written parallel to edge. \n\
4435 bv: Bottom of viewport, text written at right angles to edge. \n\
4436 l: Left of viewport, text written parallel to edge. \n\
4437 lv: Left of viewport, text written at right angles to edge. \n\
4438 r: Right of viewport, text written parallel to edge. \n\
4439 rv: Right of viewport, text written at right angles to edge. \n\
4440 t: Top of viewport, text written parallel to edge. \n\
4441 tv: Top of viewport, text written at right angles to edge. \n\
4442 \n\
4443 \n\
4444 disp (PLFLT, input) : Position of the reference point of string,\n\
4445 measured outwards from the specified viewport edge in units of the\n\
4446 current character height. Use negative disp to write within the\n\
4447 viewport. \n\
4448 \n\
4449 pos (PLFLT, input) : Position of the reference point of string\n\
4450 along the specified edge, expressed as a fraction of the length of\n\
4451 the edge. \n\
4452 \n\
4453 just (PLFLT, input) : Specifies the position of the string relative\n\
4454 to its reference point. If just=0., the reference point is at the\n\
4455 left and if just=1., it is at the right of the string. Other\n\
4456 values of just give intermediate justifications. \n\
4457 \n\
4458 text (const char *, input) : The string to be written out. \n\
4459 ";
4460 const char* _wrap_plsvect_texinfo = "-*- texinfo -*-\n\
4461 Set arrow style for vector plots \n\
4462 \n\
4463 DESCRIPTION:\n\
4464 \n\
4465 Set the style for the arrow used by plvect to plot vectors. \n\
4466 \n\
4467 Redacted form: plsvect(arrowx, arrowy, fill)\n\
4468 \n\
4469 This function is used in example 22. \n\
4470 \n\
4471 \n\
4472 \n\
4473 SYNOPSIS:\n\
4474 \n\
4475 plsvect(arrowx, arrowy, npts, fill)\n\
4476 \n\
4477 ARGUMENTS:\n\
4478 \n\
4479 arrowx, arrowy (PLFLT *,input) : Pointers to a pair of arrays\n\
4480 containing the x and y points which make up the arrow. The arrow\n\
4481 is plotted by joining these points to form a polygon. The scaling\n\
4482 assumes that the x and y points in the arrow lie in the range -0.5\n\
4483 <= x,y <= 0.5. If both arrowx and arrowy are NULL then the arrow\n\
4484 style will be reset to its default. \n\
4485 \n\
4486 npts (PLINT,input) : Number of points in the arrays arrowx and\n\
4487 arrowy. \n\
4488 \n\
4489 fill (PLBOOL,input) : If fill is true then the arrow is closed, if\n\
4490 fill is false then the arrow is open. \n\
4491 ";
4492 const char* _wrap_plgfam_texinfo = "-*- texinfo -*-\n\
4493 Get family file parameters \n\
4494 \n\
4495 DESCRIPTION:\n\
4496 \n\
4497 Gets information about current family file, if familying is enabled. \n\
4498 See the PLplot documentation for more information. \n\
4499 \n\
4500 Redacted form: plgfam(fam, num, bmax)\n\
4501 \n\
4502 This function is used in examples 14,31. \n\
4503 \n\
4504 \n\
4505 \n\
4506 SYNOPSIS:\n\
4507 \n\
4508 plgfam(fam, num, bmax)\n\
4509 \n\
4510 ARGUMENTS:\n\
4511 \n\
4512 fam (PLINT *, output) : Pointer to variable with the Boolean family\n\
4513 flag value. If nonzero, familying is enabled. \n\
4514 \n\
4515 num (PLINT *, output) : Pointer to variable with the current family\n\
4516 file number. \n\
4517 \n\
4518 bmax (PLINT *, output) : Pointer to variable with the maximum file\n\
4519 size (in bytes) for a family file. \n\
4520 ";
4521 const char* _wrap_plrandd_texinfo = "-*- texinfo -*-\n\
4522 Random number generator returning a real random number in the range [0,1]. \n\
4523 \n\
4524 DESCRIPTION:\n\
4525 \n\
4526 Random number generator returning a real random number in the range\n\
4527 [0,1]. The generator is based on the Mersenne Twister. Most languages\n\
4528 / compilers provide their own random number generator, and so this is\n\
4529 provided purely for convenience and to give a consistent random number\n\
4530 generator across all languages supported by PLplot. This is\n\
4531 particularly useful for comparing results from the test suite of\n\
4532 examples. \n\
4533 \n\
4534 Redacted form: plrandd()\n\
4535 \n\
4536 This function is used in examples 17,21. \n\
4537 \n\
4538 \n\
4539 \n\
4540 SYNOPSIS:\n\
4541 \n\
4542 plrandd()\n\
4543 ";
4544 const char* _wrap_plstyl_texinfo = "-*- texinfo -*-\n\
4545 Set line style \n\
4546 \n\
4547 DESCRIPTION:\n\
4548 \n\
4549 This sets up the line style for all lines subsequently drawn. A line\n\
4550 consists of segments in which the pen is alternately down and up. The\n\
4551 lengths of these segments are passed in the arrays mark and space\n\
4552 respectively. The number of mark-space pairs is specified by nels. \n\
4553 In order to return the line style to the default continuous line,\n\
4554 plstyl should be called with nels=0.(see also pllsty) \n\
4555 \n\
4556 Redacted form: plstyl(mark, space)\n\
4557 \n\
4558 This function is used in examples 1,9,14. \n\
4559 \n\
4560 \n\
4561 \n\
4562 SYNOPSIS:\n\
4563 \n\
4564 plstyl(nels, mark, space)\n\
4565 \n\
4566 ARGUMENTS:\n\
4567 \n\
4568 nels (PLINT, input) : The number of mark and space elements in a\n\
4569 line. Thus a simple broken line can be obtained by setting\n\
4570 nels=1. A continuous line is specified by setting nels=0. \n\
4571 \n\
4572 mark (PLINT *, input) : Pointer to array with the lengths of the\n\
4573 segments during which the pen is down, measured in micrometers. \n\
4574 \n\
4575 space (PLINT *, input) : Pointer to array with the lengths of the\n\
4576 segments during which the pen is up, measured in micrometers. \n\
4577 ";
4578 const char* _wrap_plspal0_texinfo = "-*- texinfo -*-\n\
4579 Set the colors for color table 0 from a cmap0 file \n\
4580 \n\
4581 DESCRIPTION:\n\
4582 \n\
4583 Set the colors for color table 0 from a cmap0 file \n\
4584 \n\
4585 Redacted form: plspal0(filename)\n\
4586 \n\
4587 This function is in example 16. \n\
4588 \n\
4589 \n\
4590 \n\
4591 SYNOPSIS:\n\
4592 \n\
4593 plspal0(filename)\n\
4594 \n\
4595 ARGUMENTS:\n\
4596 \n\
4597 filename (const char *, input) : The name of the cmap0 file, or a\n\
4598 empty to string to specify the default cmap0 file. \n\
4599 ";
4600 const char* _wrap_plspal1_texinfo = "-*- texinfo -*-\n\
4601 Set the colors for color table 1 from a cmap1 file \n\
4602 \n\
4603 DESCRIPTION:\n\
4604 \n\
4605 Set the colors for color table 1 from a cmap1 file \n\
4606 \n\
4607 Redacted form: plspal1(filename)\n\
4608 \n\
4609 This function is in example 16. \n\
4610 \n\
4611 \n\
4612 \n\
4613 SYNOPSIS:\n\
4614 \n\
4615 plspal1(filename)\n\
4616 \n\
4617 ARGUMENTS:\n\
4618 \n\
4619 filename (const char *, input) : The name of the cmap1 file, or a\n\
4620 empty to string to specify the default cmap1 file. \n\
4621 ";
4622 const char* _wrap_plsstrm_texinfo = "-*- texinfo -*-\n\
4623 Set current output stream \n\
4624 \n\
4625 DESCRIPTION:\n\
4626 \n\
4627 Sets the number of the current output stream. The stream number\n\
4628 defaults to 0 unless changed by this routine. The first use of this\n\
4629 routine must be followed by a call initializing PLplot (e.g. plstar). \n\
4630 \n\
4631 Redacted form: plsstrm(strm)\n\
4632 \n\
4633 This function is examples 1,14,20. \n\
4634 \n\
4635 \n\
4636 \n\
4637 SYNOPSIS:\n\
4638 \n\
4639 plsstrm(strm)\n\
4640 \n\
4641 ARGUMENTS:\n\
4642 \n\
4643 strm (PLINT, input) : The current stream number. \n\
4644 ";
4645 const char* _wrap_plvpor_texinfo = "-*- texinfo -*-\n\
4646 Specify viewport using coordinates \n\
4647 \n\
4648 DESCRIPTION:\n\
4649 \n\
4650 Device-independent routine for setting up the viewport. This defines\n\
4651 the viewport in terms of normalized subpage coordinates which run from\n\
4652 0.0 to 1.0 (left to right and bottom to top) along each edge of the\n\
4653 current subpage. Use the alternate routine plsvpa in order to create\n\
4654 a viewport of a definite size. \n\
4655 \n\
4656 Redacted form: plvpor(xmin, xmax, ymin, ymax)\n\
4657 \n\
4658 This function is used in examples\n\
4659 2,6-8,10,11,15,16,18,21,23,24,26,27,31. \n\
4660 \n\
4661 \n\
4662 \n\
4663 SYNOPSIS:\n\
4664 \n\
4665 plvpor(xmin, xmax, ymin, ymax)\n\
4666 \n\
4667 ARGUMENTS:\n\
4668 \n\
4669 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
4670 left-hand edge of the viewport. \n\
4671 \n\
4672 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
4673 right-hand edge of the viewport. \n\
4674 \n\
4675 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
4676 bottom edge of the viewport. \n\
4677 \n\
4678 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
4679 edge of the viewport. \n\
4680 ";
4681 const char* _wrap_plptex_texinfo = "-*- texinfo -*-\n\
4682 Write text inside the viewport \n\
4683 \n\
4684 DESCRIPTION:\n\
4685 \n\
4686 Writes text at a specified position and inclination within the\n\
4687 viewport. Text is clipped at the viewport boundaries. The reference\n\
4688 point of a string lies along a line passing through the string at half\n\
4689 the height of a capital letter. The position of the reference point\n\
4690 along this line is determined by just, the reference point is placed\n\
4691 at world coordinates (\n\
4692 x, \n\
4693 y) within the viewport. The inclination of the string is specified in\n\
4694 terms of differences of world coordinates making it easy to write text\n\
4695 parallel to a line in a graph. \n\
4696 \n\
4697 Redacted form: plptex(x, y, dx, dy, just, text)\n\
4698 \n\
4699 This function is used in example 2-4,10,12-14,20,23,24,26. \n\
4700 \n\
4701 \n\
4702 \n\
4703 SYNOPSIS:\n\
4704 \n\
4705 plptex(x, y, dx, dy, just, text)\n\
4706 \n\
4707 ARGUMENTS:\n\
4708 \n\
4709 x (PLFLT, input) : x coordinate of reference point of string. \n\
4710 \n\
4711 y (PLFLT, input) : y coordinate of reference point of string. \n\
4712 \n\
4713 dx (PLFLT, input) : Together with dy, this specifies the\n\
4714 inclination of the string. The baseline of the string is parallel\n\
4715 to a line joining (\n\
4716 x, \n\
4717 y) to (\n\
4718 x+\n\
4719 dx, \n\
4720 y+\n\
4721 dy). \n\
4722 \n\
4723 dy (PLFLT, input) : Together with dx, this specifies the\n\
4724 inclination of the string. \n\
4725 \n\
4726 just (PLFLT, input) : Specifies the position of the string relative\n\
4727 to its reference point. If just=0., the reference point is at the\n\
4728 left and if just=1., it is at the right of the string. Other\n\
4729 values of just give intermediate justifications. \n\
4730 \n\
4731 text (const char *, input) : The string to be written out. \n\
4732 ";
4733 const char* _wrap_plszax_texinfo = "-*- texinfo -*-\n\
4734 Set z axis parameters \n\
4735 \n\
4736 DESCRIPTION:\n\
4737 \n\
4738 Identical to plsxax, except that arguments are flags for z axis. See\n\
4739 the description of plsxax for more detail. \n\
4740 \n\
4741 Redacted form: plszax(digmax, digits)\n\
4742 \n\
4743 This function is used in example 31. \n\
4744 \n\
4745 \n\
4746 \n\
4747 SYNOPSIS:\n\
4748 \n\
4749 plszax(digmax, digits)\n\
4750 \n\
4751 ARGUMENTS:\n\
4752 \n\
4753 digmax (PLINT, input) : Variable to set the maximum number of\n\
4754 digits for the z axis. If nonzero, the printed label will be\n\
4755 switched to a floating point representation when the number of\n\
4756 digits exceeds digmax. \n\
4757 \n\
4758 digits (PLINT, input) : Field digits value. Currently, changing\n\
4759 its value here has no effect since it is set only by plbox or\n\
4760 plbox3. However, the user may obtain its value after a call to\n\
4761 either of these functions by calling plgzax. \n\
4762 ";
4763 const char* _wrap_plfont_texinfo = "-*- texinfo -*-\n\
4764 Set character font \n\
4765 \n\
4766 DESCRIPTION:\n\
4767 \n\
4768 Sets the default character font for subsequent character drawing. Also\n\
4769 affects symbols produced by plpoin. This routine has no effect unless\n\
4770 the extended character set is loaded (see plfontld). \n\
4771 \n\
4772 Redacted form: plfont(font)\n\
4773 \n\
4774 This function is used in examples 1,2,4,7,13,24,26. \n\
4775 \n\
4776 \n\
4777 \n\
4778 SYNOPSIS:\n\
4779 \n\
4780 plfont(font)\n\
4781 \n\
4782 ARGUMENTS:\n\
4783 \n\
4784 font (PLINT, input) : Specifies the font: 1: Normal font (simplest\n\
4785 and fastest) \n\
4786 2: Roman font \n\
4787 3: Italic font \n\
4788 4: Script font \n\
4789 ";
4790 const char* _wrap_plarc_texinfo = "-*- texinfo -*-\n\
4791 Draw a circular or elliptical arc \n\
4792 \n\
4793 DESCRIPTION:\n\
4794 \n\
4795 Draw a possibly filled arc centered at x, y with semimajor axis a and\n\
4796 semiminor axis b, starting at angle1 and ending at angle2. \n\
4797 \n\
4798 Redacted form: General: plarc(x, y, a, b, angle1, angle2, rotate,\n\
4799 fill)\n\
4800 \n\
4801 \n\
4802 This function is used in examples 3 and 27. \n\
4803 \n\
4804 \n\
4805 \n\
4806 SYNOPSIS:\n\
4807 \n\
4808 plarc(x, y, a, b, angle1, angle2, rotate, fill)\n\
4809 \n\
4810 ARGUMENTS:\n\
4811 \n\
4812 x (PLFLT, input) : X coordinate of arc center. \n\
4813 \n\
4814 y (PLFLT, input) : Y coordinate of arc center. \n\
4815 \n\
4816 a (PLFLT, input) : Length of the semimajor axis of the arc. \n\
4817 \n\
4818 b (PLFLT, input) : Length of the semiminor axis of the arc. \n\
4819 \n\
4820 angle1 (PLFLT, input) : Starting angle of the arc relative to the\n\
4821 semimajor axis. \n\
4822 \n\
4823 angle2 (PLFLT, input) : Ending angle of the arc relative to the\n\
4824 semimajor axis. \n\
4825 \n\
4826 rotate (PLFLT, input) : Angle of the semimajor axis relative to the\n\
4827 X-axis. \n\
4828 \n\
4829 fill (PLBOOL, input) : Draw a filled arc. \n\
4830 ";
4831 const char* _wrap_plpat_texinfo = "-*- texinfo -*-\n\
4832 Set area fill pattern \n\
4833 \n\
4834 DESCRIPTION:\n\
4835 \n\
4836 Sets the area fill pattern. The pattern consists of 1 or 2 sets of\n\
4837 parallel lines with specified inclinations and spacings. The\n\
4838 arguments to this routine are the number of sets to use (1 or 2)\n\
4839 followed by two pointers to integer arrays (of 1 or 2 elements)\n\
4840 specifying the inclinations in tenths of a degree and the spacing in\n\
4841 micrometers. (also see plpsty) \n\
4842 \n\
4843 Redacted form: General: plpat(inc, del)\n\
4844 \t Perl/PDL: plpat(nlin, inc, del)\n\
4845 \n\
4846 \n\
4847 This function is used in example 15. \n\
4848 \n\
4849 \n\
4850 \n\
4851 SYNOPSIS:\n\
4852 \n\
4853 plpat(nlin, inc, del)\n\
4854 \n\
4855 ARGUMENTS:\n\
4856 \n\
4857 nlin (PLINT, input) : Number of sets of lines making up the\n\
4858 pattern, either 1 or 2. \n\
4859 \n\
4860 inc (PLINT *, input) : Pointer to array with nlin elements.\n\
4861 Specifies the line inclination in tenths of a degree. (Should be\n\
4862 between -900 and 900). \n\
4863 \n\
4864 del (PLINT *, input) : Pointer to array with nlin elements.\n\
4865 Specifies the spacing in micrometers between the lines making up\n\
4866 the pattern. \n\
4867 ";
4868 const char* _wrap_plgxax_texinfo = "-*- texinfo -*-\n\
4869 Get x axis parameters \n\
4870 \n\
4871 DESCRIPTION:\n\
4872 \n\
4873 Returns current values of the digmax and digits flags for the x axis. \n\
4874 digits is updated after the plot is drawn, so this routine should only\n\
4875 be called after the call to plbox (or plbox3) is complete.\tSee the\n\
4876 PLplot documentation for more information. \n\
4877 \n\
4878 Redacted form: plgxax(digmax, digits)\n\
4879 \n\
4880 This function is used in example 31. \n\
4881 \n\
4882 \n\
4883 \n\
4884 SYNOPSIS:\n\
4885 \n\
4886 plgxax(digmax, digits)\n\
4887 \n\
4888 ARGUMENTS:\n\
4889 \n\
4890 digmax (PLINT *, output) : Pointer to variable with the maximum\n\
4891 number of digits for the x axis. If nonzero, the printed label\n\
4892 has been switched to a floating point representation when the\n\
4893 number of digits exceeds digmax. \n\
4894 \n\
4895 digits (PLINT *, output) : Pointer to variable with the actual\n\
4896 number of digits for the numeric labels (x axis) from the last\n\
4897 plot. \n\
4898 ";
4899 const char* _wrap_plfill3_texinfo = "-*- texinfo -*-\n\
4900 Draw filled polygon in 3D \n\
4901 \n\
4902 DESCRIPTION:\n\
4903 \n\
4904 Fills the 3D polygon defined by the n points in the x, y, and z arrays\n\
4905 using the pattern defined by plpsty or plpat. The routine will\n\
4906 automatically close the polygon between the last and first vertices. \n\
4907 If multiple closed polygons are passed in x, y, and z then plfill3\n\
4908 will fill in between them. \n\
4909 \n\
4910 Redacted form: General: plfill3(x, y, z)\n\
4911 \t Perl/PDL: plfill3(n, x, y, z)\n\
4912 \n\
4913 \n\
4914 This function is used in example 15. \n\
4915 \n\
4916 \n\
4917 \n\
4918 SYNOPSIS:\n\
4919 \n\
4920 plfill3(n, x, y, z)\n\
4921 \n\
4922 ARGUMENTS:\n\
4923 \n\
4924 n (PLINT, input) : Number of vertices in polygon. \n\
4925 \n\
4926 x (PLFLT *, input) : Pointer to array with x coordinates of\n\
4927 vertices. \n\
4928 \n\
4929 y (PLFLT *, input) : Pointer to array with y coordinates of\n\
4930 vertices. \n\
4931 \n\
4932 z (PLFLT *, input) : Pointer to array with z coordinates of\n\
4933 vertices. \n\
4934 ";
4935 const char* _wrap_plcol0_texinfo = "-*- texinfo -*-\n\
4936 Set color, map0 \n\
4937 \n\
4938 DESCRIPTION:\n\
4939 \n\
4940 Sets the color for color map0 (see the PLplot documentation). \n\
4941 \n\
4942 Redacted form: plcol0(color)\n\
4943 \n\
4944 This function is used in examples 1-9,11-16,18-27,29. \n\
4945 \n\
4946 \n\
4947 \n\
4948 SYNOPSIS:\n\
4949 \n\
4950 plcol0(color)\n\
4951 \n\
4952 ARGUMENTS:\n\
4953 \n\
4954 color (PLINT, input) : Integer representing the color. The\n\
4955 defaults at present are (these may change): \n\
4956 0 black (default background) \n\
4957 1 red (default foreground) \n\
4958 2 yellow \n\
4959 3 green \n\
4960 4 aquamarine \n\
4961 5 pink \n\
4962 6 wheat \n\
4963 7 grey \n\
4964 8 brown \n\
4965 9 blue \n\
4966 10 BlueViolet \n\
4967 11 cyan \n\
4968 12 turquoise \n\
4969 13 magenta \n\
4970 14 salmon \n\
4971 15 white \n\
4972 \n\
4973 Use plscmap0 to change the entire map0 color palette and plscol0 to\n\
4974 change an individual color in the map0 color palette. \n\
4975 ";
4976 const char* _wrap_pljoin_texinfo = "-*- texinfo -*-\n\
4977 Draw a line between two points \n\
4978 \n\
4979 DESCRIPTION:\n\
4980 \n\
4981 Joins the point (\n\
4982 x1, \n\
4983 y1) to (\n\
4984 x2, \n\
4985 y2). \n\
4986 \n\
4987 Redacted form: pljoin(x1,y1,x2,y2)\n\
4988 \n\
4989 This function is used in examples 3,14. \n\
4990 \n\
4991 \n\
4992 \n\
4993 SYNOPSIS:\n\
4994 \n\
4995 pljoin(x1, y1, x2, y2)\n\
4996 \n\
4997 ARGUMENTS:\n\
4998 \n\
4999 x1 (PLFLT, input) : x coordinate of first point. \n\
5000 \n\
5001 y1 (PLFLT, input) : y coordinate of first point. \n\
5002 \n\
5003 x2 (PLFLT, input) : x coordinate of second point. \n\
5004 \n\
5005 y2 (PLFLT, input) : y coordinate of second point. \n\
5006 ";
5007 const char* _wrap_plcol1_texinfo = "-*- texinfo -*-\n\
5008 Set color, map1 \n\
5009 \n\
5010 DESCRIPTION:\n\
5011 \n\
5012 Sets the color for color map1 (see the PLplot documentation). \n\
5013 \n\
5014 Redacted form: plcol1(col1)\n\
5015 \n\
5016 This function is used in examples 12 and 21. \n\
5017 \n\
5018 \n\
5019 \n\
5020 SYNOPSIS:\n\
5021 \n\
5022 plcol1(col1)\n\
5023 \n\
5024 ARGUMENTS:\n\
5025 \n\
5026 col1 (PLFLT, input) : This value must be in the range from 0. to 1.\n\
5027 and is mapped to color using the continuous map1 color palette\n\
5028 which by default ranges from blue to the background color to red. \n\
5029 The map1 palette can also be straightforwardly changed by the user\n\
5030 with plscmap1 or plscmap1l. \n\
5031 ";
5032 const char* _wrap_plsori_texinfo = "-*- texinfo -*-\n\
5033 Set orientation \n\
5034 \n\
5035 DESCRIPTION:\n\
5036 \n\
5037 Set integer plot orientation parameter. This function is identical to\n\
5038 plsdiori except for the type of the argument, and should be used in\n\
5039 the same way. See the PLplot documentation for details. \n\
5040 \n\
5041 Redacted form: plsori(ori)\n\
5042 \n\
5043 This function is used in example 3. \n\
5044 \n\
5045 \n\
5046 \n\
5047 SYNOPSIS:\n\
5048 \n\
5049 plsori(ori)\n\
5050 \n\
5051 ARGUMENTS:\n\
5052 \n\
5053 ori (PLINT, input) : Orientation value (0 for landscape, 1 for\n\
5054 portrait, etc.) The value is multiplied by 90 degrees to get the\n\
5055 angle. \n\
5056 ";
5057 const char* _wrap_plmap_texinfo = "-*- texinfo -*-\n\
5058 Plot continental outline in world coordinates. \n\
5059 \n\
5060 DESCRIPTION:\n\
5061 \n\
5062 Plots continental outlines in world coordinates. examples/c/x19c\n\
5063 demonstrates how to use this function to create different\n\
5064 projections. \n\
5065 \n\
5066 Redacted form: General: plmap(mapform, type, minlong, maxlong,\n\
5067 minlat, maxlat)\n\
5068 \t F95, Java, Perl/PDL, Python: Not implemented? \n\
5069 \n\
5070 \n\
5071 This function is used in example 19. \n\
5072 \n\
5073 \n\
5074 \n\
5075 SYNOPSIS:\n\
5076 \n\
5077 plmap(mapform, type, minlong, maxlong, minlat, maxlat)\n\
5078 \n\
5079 ARGUMENTS:\n\
5080 \n\
5081 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
5082 supplied function to transform the coordinate longitudes and\n\
5083 latitudes to a plot coordinate system. By using this transform,\n\
5084 we can change from a longitude, latitude coordinate to a polar\n\
5085 stereographic project, for example. Initially, x[0]..[n-1] are\n\
5086 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
5087 After the call to mapform(), x[] and y[] should be replaced by\n\
5088 the corresponding plot coordinates. If no transform is desired,\n\
5089 mapform can be replaced by NULL. \n\
5090 \n\
5091 type (char *, input) : type is a character string. The value of\n\
5092 this parameter determines the type of background. The possible\n\
5093 values are: \"globe\" -- continental outlines \n\
5094 \"usa\" -- USA and state boundaries \n\
5095 \"cglobe\" -- continental outlines and countries \n\
5096 \"usaglobe\" -- USA, state boundaries and continental outlines \n\
5097 \n\
5098 \n\
5099 minlong (PLFLT, input) : The value of the longitude on the left\n\
5100 side of the plot. The value of minlong must be less than the\n\
5101 value of maxlong, and the quantity maxlong-minlong must be less\n\
5102 than or equal to 360. \n\
5103 \n\
5104 maxlong (PLFLT, input) : The value of the longitude on the right\n\
5105 side of the plot. \n\
5106 \n\
5107 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
5108 background. One can always use -90.0 as the boundary outside the\n\
5109 plot window will be automatically eliminated. However, the\n\
5110 program will be faster if one can reduce the size of the\n\
5111 background plotted. \n\
5112 \n\
5113 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
5114 background. One can always use 90.0 as the boundary outside the\n\
5115 plot window will be automatically eliminated. \n\
5116 ";
5117 const char* _wrap_plgstrm_texinfo = "-*- texinfo -*-\n\
5118 Get current stream number \n\
5119 \n\
5120 DESCRIPTION:\n\
5121 \n\
5122 Gets the number of the current output stream. See also plsstrm. \n\
5123 \n\
5124 Redacted form: plgstrm(strm)\n\
5125 \n\
5126 This function is used in example 1,20. \n\
5127 \n\
5128 \n\
5129 \n\
5130 SYNOPSIS:\n\
5131 \n\
5132 plgstrm(strm)\n\
5133 \n\
5134 ARGUMENTS:\n\
5135 \n\
5136 strm (PLINT *, output) : Pointer to current stream value. \n\
5137 ";
5138 const char* _wrap_plline3_texinfo = "-*- texinfo -*-\n\
5139 Draw a line in 3 space \n\
5140 \n\
5141 DESCRIPTION:\n\
5142 \n\
5143 Draws line in 3 space defined by n points in x, y, and z. You must\n\
5144 first set up the viewport, the 2d viewing window (in world\n\
5145 coordinates), and the 3d normalized coordinate box. See x18c.c for\n\
5146 more info. \n\
5147 \n\
5148 Redacted form: plline3(x, y, z)\n\
5149 \n\
5150 This function is used in example 18. \n\
5151 \n\
5152 \n\
5153 \n\
5154 SYNOPSIS:\n\
5155 \n\
5156 plline3(n, x, y, z)\n\
5157 \n\
5158 ARGUMENTS:\n\
5159 \n\
5160 n (PLINT, input) : Number of points defining line. \n\
5161 \n\
5162 x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
5163 \n\
5164 y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
5165 \n\
5166 z (PLFLT *, input) : Pointer to array with z coordinates of points. \n\
5167 ";
5168 const char* _wrap_plfontld_texinfo = "-*- texinfo -*-\n\
5169 Load character font \n\
5170 \n\
5171 DESCRIPTION:\n\
5172 \n\
5173 Sets the character set to use for subsequent character drawing. May\n\
5174 be called before initializing PLplot. \n\
5175 \n\
5176 Redacted form: plfontld(set)\n\
5177 \n\
5178 This function is used in examples 1,7. \n\
5179 \n\
5180 \n\
5181 \n\
5182 SYNOPSIS:\n\
5183 \n\
5184 plfontld(set)\n\
5185 \n\
5186 ARGUMENTS:\n\
5187 \n\
5188 set (PLINT, input) : Specifies the character set to load: 0:\n\
5189 Standard character set \n\
5190 1: Extended character set \n\
5191 ";
5192 const char* _wrap_plSetOpt_texinfo = "-*- texinfo -*-\n\
5193 Set any command-line option \n\
5194 \n\
5195 DESCRIPTION:\n\
5196 \n\
5197 Set any command-line option internally from a program before it\n\
5198 invokes plinit. opt is the name of the command-line option and optarg\n\
5199 is the corresponding command-line option argument.\t\n\
5200 \n\
5201 This function returns 0 on success. \n\
5202 \n\
5203 Redacted form: plsetopt(opt, optarg)\n\
5204 \n\
5205 This function is used in example 14. \n\
5206 \n\
5207 \n\
5208 \n\
5209 SYNOPSIS:\n\
5210 \n\
5211 int plsetopt(opt, optarg)\n\
5212 \n\
5213 ARGUMENTS:\n\
5214 \n\
5215 opt (const char *, input) : Pointer to string containing the\n\
5216 command-line option. \n\
5217 \n\
5218 optarg (const char *, input) : Pointer to string containing the\n\
5219 argument of the command-line option. \n\
5220 ";
5221 const char* _wrap_plscolor_texinfo = "-*- texinfo -*-\n\
5222 Used to globally turn color output on/off \n\
5223 \n\
5224 DESCRIPTION:\n\
5225 \n\
5226 Used to globally turn color output on/off for those drivers/devices\n\
5227 that support it. \n\
5228 \n\
5229 Redacted form: plscolor(color)\n\
5230 \n\
5231 This function is used in example 31. \n\
5232 \n\
5233 \n\
5234 \n\
5235 SYNOPSIS:\n\
5236 \n\
5237 plscolor(color)\n\
5238 \n\
5239 ARGUMENTS:\n\
5240 \n\
5241 color (PLINT, input) : Color flag (Boolean). If zero, color is\n\
5242 turned off. If non-zero, color is turned on. \n\
5243 ";
5244 const char* _wrap_plgdev_texinfo = "-*- texinfo -*-\n\
5245 Get the current device (keyword) name \n\
5246 \n\
5247 DESCRIPTION:\n\
5248 \n\
5249 Get the current device (keyword) name. Note: you must have allocated\n\
5250 space for this (80 characters is safe). \n\
5251 \n\
5252 Redacted form: plgdev(p_dev)\n\
5253 \n\
5254 This function is used in example 14. \n\
5255 \n\
5256 \n\
5257 \n\
5258 SYNOPSIS:\n\
5259 \n\
5260 plgdev(p_dev)\n\
5261 \n\
5262 ARGUMENTS:\n\
5263 \n\
5264 p_dev (char *, output) : Pointer to device (keyword) name string. \n\
5265 ";
5266 const char* _wrap_plstripa_texinfo = "-*- texinfo -*-\n\
5267 Add a point to a strip chart \n\
5268 \n\
5269 DESCRIPTION:\n\
5270 \n\
5271 Add a point to a given pen of a given strip chart. There is no need\n\
5272 for all pens to have the same number of points or to be equally\n\
5273 sampled in the x coordinate. Allocates memory and rescales as\n\
5274 necessary. \n\
5275 \n\
5276 Redacted form: plstripa(id, p, x, y)\n\
5277 \n\
5278 This function is used in example 17. \n\
5279 \n\
5280 \n\
5281 \n\
5282 SYNOPSIS:\n\
5283 \n\
5284 plstripa(id, p, x, y)\n\
5285 \n\
5286 ARGUMENTS:\n\
5287 \n\
5288 id (PLINT, input) : Identification number (set up in plstripc) of\n\
5289 the strip chart. \n\
5290 \n\
5291 p (PLINT, input) : Pen number (ranges from 0 to 3). \n\
5292 \n\
5293 x (PLFLT, input) : X coordinate of point to plot. \n\
5294 \n\
5295 y (PLFLT, input) : Y coordinate of point to plot. \n\
5296 ";
5297 const char* _wrap_plstripd_texinfo = "-*- texinfo -*-\n\
5298 Deletes and releases memory used by a strip chart \n\
5299 \n\
5300 DESCRIPTION:\n\
5301 \n\
5302 Deletes and releases memory used by a strip chart. \n\
5303 \n\
5304 Redacted form: plstripd(id)\n\
5305 \n\
5306 This function is used in example 17. \n\
5307 \n\
5308 \n\
5309 \n\
5310 SYNOPSIS:\n\
5311 \n\
5312 plstripd(id)\n\
5313 \n\
5314 ARGUMENTS:\n\
5315 \n\
5316 id (PLINT, input) : Identification number of strip chart to delete. \n\
5317 ";
5318 const char* _wrap_plvpas_texinfo = "-*- texinfo -*-\n\
5319 Specify viewport using coordinates and aspect ratio \n\
5320 \n\
5321 DESCRIPTION:\n\
5322 \n\
5323 Device-independent routine for setting up the viewport. The viewport\n\
5324 is chosen to be the largest with the given aspect ratio that fits\n\
5325 within the specified region (in terms of normalized subpage\n\
5326 coordinates). This routine is functionally equivalent to plvpor when\n\
5327 a ``natural\'\' aspect ratio (0.0) is chosen. Unlike plvasp, this\n\
5328 routine reserves no extra space at the edges for labels. \n\
5329 \n\
5330 Redacted form: plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5331 \n\
5332 This function is used in example 9. \n\
5333 \n\
5334 \n\
5335 \n\
5336 SYNOPSIS:\n\
5337 \n\
5338 plvpas(xmin, xmax, ymin, ymax, aspect)\n\
5339 \n\
5340 ARGUMENTS:\n\
5341 \n\
5342 xmin (PLFLT, input) : The normalized subpage coordinate of the\n\
5343 left-hand edge of the viewport. \n\
5344 \n\
5345 xmax (PLFLT, input) : The normalized subpage coordinate of the\n\
5346 right-hand edge of the viewport. \n\
5347 \n\
5348 ymin (PLFLT, input) : The normalized subpage coordinate of the\n\
5349 bottom edge of the viewport. \n\
5350 \n\
5351 ymax (PLFLT, input) : The normalized subpage coordinate of the top\n\
5352 edge of the viewport. \n\
5353 \n\
5354 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
5355 axis. \n\
5356 ";
5357 const char* _wrap_plslabelfunc_texinfo = "-*- texinfo -*-\n\
5358 Assign a function to use for generating custom axis labels \n\
5359 \n\
5360 DESCRIPTION:\n\
5361 \n\
5362 This function allows a user to provide their own function to provide\n\
5363 axis label text. The user function is given the numeric value for a\n\
5364 point on an axis and returns a string label to correspond with that\n\
5365 value. Custom axis labels can be enabled by passing appropriate\n\
5366 arguments to plenv, plbox, plbox3 and similar functions. \n\
5367 \n\
5368 This function is used in example 19. \n\
5369 \n\
5370 \n\
5371 \n\
5372 SYNOPSIS:\n\
5373 \n\
5374 plslabelfunc(label_func, label_data)\n\
5375 \n\
5376 ARGUMENTS:\n\
5377 \n\
5378 label_func (void (*) (PLINT, PLFLT, char *, PLINT, void *), input) : \n\
5379 This is the custom label function. In order to reset to the\n\
5380 default labelling, set this to NULL. The labelling function\n\
5381 parameters are, in order: axis: This indicates which axis a\n\
5382 label is being requested for. The value will be one of PL_X_AXIS,\n\
5383 PL_Y_AXIS or PL_Z_AXIS. \n\
5384 \n\
5385 value: This is the value along the axis which is being labelled. \n\
5386 \n\
5387 label_text: The string representation of the label value. \n\
5388 \n\
5389 length: The maximum length in characters allowed for label_text. \n\
5390 \n\
5391 \n\
5392 label_data (void *, input) : This parameter may be used to pass\n\
5393 data to the label_func function. \n\
5394 ";
5395 const char* _wrap_plsmaj_texinfo = "-*- texinfo -*-\n\
5396 Set length of major ticks \n\
5397 \n\
5398 DESCRIPTION:\n\
5399 \n\
5400 This sets up the length of the major ticks. The actual length is the\n\
5401 product of the default length and a scaling factor as for character\n\
5402 height. \n\
5403 \n\
5404 Redacted form: plsmaj(def, scale)\n\
5405 \n\
5406 This function is used in example 29. \n\
5407 \n\
5408 \n\
5409 \n\
5410 SYNOPSIS:\n\
5411 \n\
5412 plsmaj(def, scale)\n\
5413 \n\
5414 ARGUMENTS:\n\
5415 \n\
5416 def (PLFLT, input) : The default length of a major tick in\n\
5417 millimeters, should be set to zero if the default length is to\n\
5418 remain unchanged. \n\
5419 \n\
5420 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
5421 actual tick length. \n\
5422 ";
5423 const char* _wrap_plgver_texinfo = "-*- texinfo -*-\n\
5424 Get the current library version number \n\
5425 \n\
5426 DESCRIPTION:\n\
5427 \n\
5428 Get the current library version number. Note: you must have allocated\n\
5429 space for this (80 characters is safe). \n\
5430 \n\
5431 Redacted form: plgver(p_ver)\n\
5432 \n\
5433 This function is used in example 1. \n\
5434 \n\
5435 \n\
5436 \n\
5437 SYNOPSIS:\n\
5438 \n\
5439 plgver(p_ver)\n\
5440 \n\
5441 ARGUMENTS:\n\
5442 \n\
5443 p_ver (char *, output) : Pointer to the current library version\n\
5444 number. \n\
5445 ";
5446 const char* _wrap_pl_setcontlabelformat_texinfo = "-*- texinfo -*-\n\
5447 Set format of numerical label for contours\n\
5448 \n\
5449 DESCRIPTION:\n\
5450 \n\
5451 Set format of numerical label for contours. \n\
5452 \n\
5453 Redacted form: pl_setcontlabelformat(lexp, sigdig)\n\
5454 \n\
5455 This function is used example 9. \n\
5456 \n\
5457 \n\
5458 \n\
5459 SYNOPSIS:\n\
5460 \n\
5461 pl_setcontlabelformat(lexp, sigdig)\n\
5462 \n\
5463 ARGUMENTS:\n\
5464 \n\
5465 lexp (PLINT, input) : If the contour numerical label is greater\n\
5466 than 10^(lexp) or less than 10^(-lexp), then the exponential\n\
5467 format is used. Default value of lexp is 4. \n\
5468 \n\
5469 sigdig (PLINT, input) : Number of significant digits. Default\n\
5470 value is 2. \n\
5471 ";
5472 const char* _wrap_plparseopts_texinfo = "-*- texinfo -*-\n\
5473 Parse command-line arguments \n\
5474 \n\
5475 DESCRIPTION:\n\
5476 \n\
5477 Parse command-line arguments. \n\
5478 \n\
5479 plparseopts removes all recognized flags (decreasing argc\n\
5480 accordingly), so that invalid input may be readily detected. It can\n\
5481 also be used to process user command line flags. The user can merge\n\
5482 an option table of type PLOptionTable into the internal option table\n\
5483 info structure using plMergeOpts. Or, the user can specify that ONLY\n\
5484 the external table(s) be parsed by calling plClearOpts before\n\
5485 plMergeOpts. \n\
5486 \n\
5487 The default action taken by plparseopts is as follows: \n\
5488 Returns with an error if an unrecognized option or badly formed\n\
5489 option-value pair are encountered.\t\n\
5490 Returns immediately (return code 0) when the first non-option command\n\
5491 line argument is found. \n\
5492 Returns with the return code of the option handler, if one was called.\n\
5493 \n\
5494 Deletes command line arguments from argv list as they are found, and\n\
5495 decrements argc accordingly. \n\
5496 Does not show \"invisible\" options in usage or help messages. \n\
5497 Assumes the program name is contained in argv[0]. \n\
5498 \n\
5499 These behaviors may be controlled through the \n\
5500 mode argument. \n\
5501 \n\
5502 Redacted form: General: plparseopts(argv, mode)\n\
5503 \t Perl/PDL: Not available? \n\
5504 \n\
5505 \n\
5506 This function is used in all of the examples. \n\
5507 \n\
5508 \n\
5509 \n\
5510 SYNOPSIS:\n\
5511 \n\
5512 int plparseopts(p_argc, argv, mode)\n\
5513 \n\
5514 ARGUMENTS:\n\
5515 \n\
5516 p_argc (int *, input) : pointer to number of arguments. \n\
5517 \n\
5518 argv (char **, input) : Pointer to character array containing\n\
5519 *p_argc command-line arguments. \n\
5520 \n\
5521 mode (PLINT, input) : Parsing mode with the following\n\
5522 possibilities: PL_PARSE_FULL (1) -- Full parsing of command line\n\
5523 and all error messages enabled, including program exit when an\n\
5524 error occurs. Anything on the command line that isn\'t recognized\n\
5525 as a valid option or option argument is flagged as an error. \n\
5526 PL_PARSE_QUIET (2) -- Turns off all output except in the case\n\
5527 of errors. \n\
5528 PL_PARSE_NODELETE (4) -- Turns off deletion of processed\n\
5529 arguments. \n\
5530 PL_PARSE_SHOWALL (8) -- Show invisible options \n\
5531 PL_PARSE_NOPROGRAM (32) -- Specified if argv[0] is NOT a\n\
5532 pointer to the program name. \n\
5533 PL_PARSE_NODASH (64) -- Set if leading dash is NOT required. \n\
5534 PL_PARSE_SKIP (128) -- Set to quietly skip over any\n\
5535 unrecognized arguments. \n\
5536 ";
5537 const char* _wrap_plstar_texinfo = "-*- texinfo -*-\n\
5538 Initialization \n\
5539 \n\
5540 DESCRIPTION:\n\
5541 \n\
5542 Initializing the plotting package.\tThe program prompts for the device\n\
5543 keyword or number of the desired output device. Hitting a RETURN in\n\
5544 response to the prompt is the same as selecting the first device. If\n\
5545 only one device is enabled when PLplot is installed, plstar will issue\n\
5546 no prompt.\tThe output device is divided into nx by ny subpages, each\n\
5547 of which may be used independently. The subroutine pladv is used to\n\
5548 advance from one subpage to the next. \n\
5549 \n\
5550 Redacted form: plstar(nx, ny)\n\
5551 \n\
5552 This function is used in example 1. \n\
5553 \n\
5554 \n\
5555 \n\
5556 SYNOPSIS:\n\
5557 \n\
5558 plstar(nx, ny)\n\
5559 \n\
5560 ARGUMENTS:\n\
5561 \n\
5562 nx (PLINT, input) : Number of subpages to divide output page in the\n\
5563 horizontal direction. \n\
5564 \n\
5565 ny (PLINT, input) : Number of subpages to divide output page in the\n\
5566 vertical direction. \n\
5567 ";
5568 const char* _wrap_plgfci_texinfo = "-*- texinfo -*-\n\
5569 Get FCI (font characterization integer) \n\
5570 \n\
5571 DESCRIPTION:\n\
5572 \n\
5573 Gets information about the current font using the FCI approach. See\n\
5574 the PLplot documentation for more information. \n\
5575 \n\
5576 Redacted form: plgfci(fci)\n\
5577 \n\
5578 This function is used in example 23. \n\
5579 \n\
5580 \n\
5581 \n\
5582 SYNOPSIS:\n\
5583 \n\
5584 plgfci(fci)\n\
5585 \n\
5586 ARGUMENTS:\n\
5587 \n\
5588 fci (PLUNICODE *, output) : Pointer to PLUNICODE (unsigned 32-bit\n\
5589 integer) variable which is updated with current FCI value. \n\
5590 ";
5591 const char* _wrap_plsfam_texinfo = "-*- texinfo -*-\n\
5592 Set family file parameters \n\
5593 \n\
5594 DESCRIPTION:\n\
5595 \n\
5596 Sets variables dealing with output file familying.\tDoes nothing if\n\
5597 familying not supported by the driver. This routine, if used, must be\n\
5598 called before initializing PLplot.\tSee the PLplot documentation for\n\
5599 more information. \n\
5600 \n\
5601 Redacted form: plsfam(fam, num, bmax)\n\
5602 \n\
5603 This function is used in examples 14,31. \n\
5604 \n\
5605 \n\
5606 \n\
5607 SYNOPSIS:\n\
5608 \n\
5609 plsfam(fam, num, bmax)\n\
5610 \n\
5611 ARGUMENTS:\n\
5612 \n\
5613 fam (PLINT, input) : Family flag (Boolean). If nonzero, familying\n\
5614 is enabled. \n\
5615 \n\
5616 num (PLINT, input) : Current family file number. \n\
5617 \n\
5618 bmax (PLINT, input) : Maximum file size (in bytes) for a family\n\
5619 file. \n\
5620 ";
5621 const char* _wrap_plscmap1la_texinfo = "-*- texinfo -*-\n\
5622 Set color map1 colors using a piece-wise linear relationship \n\
5623 \n\
5624 DESCRIPTION:\n\
5625 \n\
5626 This is a version of plscmap1l that supports alpha transparency. It\n\
5627 sets color map1 colors using a piece-wise linear relationship between\n\
5628 position in the color map (from 0 to 1) and position in HLS or RGB\n\
5629 color space (see the PLplot documentation) with alpha value (0.0 -\n\
5630 1.0). It may be called at any time. \n\
5631 \n\
5632 This function is used in example 30. \n\
5633 \n\
5634 \n\
5635 \n\
5636 SYNOPSIS:\n\
5637 \n\
5638 plscmap1la(itype, npts, pos, coord1, coord2, coord3, coord4, alt_hue_path)\n\
5639 \n\
5640 ARGUMENTS:\n\
5641 \n\
5642 itype (PLBOOL, input) : true: RGB, false: HLS. \n\
5643 \n\
5644 npts (PLINT, input) : number of control points \n\
5645 \n\
5646 pos (PLFLT *, input) : position for each control point (between 0.0\n\
5647 and 1.0, in ascending order) \n\
5648 \n\
5649 coord1 (PLFLT *, input) : first coordinate (H or R) for each\n\
5650 control point \n\
5651 \n\
5652 coord2 (PLFLT *, input) : second coordinate (L or G) for each\n\
5653 control point \n\
5654 \n\
5655 coord3 (PLFLT *, input) : third coordinate (S or B) for each\n\
5656 control point \n\
5657 \n\
5658 coord4 (PLFLT *, input) : fourth coordinate, the alpha value for\n\
5659 each control point \n\
5660 \n\
5661 alt_hue_path (PLBOOL: *, input) : alternative interpolation method\n\
5662 flag for each control point. (alt_hue_path[i] refers to the\n\
5663 interpolation interval between the i and i + 1 control points). \n\
5664 ";
5665 const char* _wrap_plspage_texinfo = "-*- texinfo -*-\n\
5666 Set page parameters \n\
5667 \n\
5668 DESCRIPTION:\n\
5669 \n\
5670 Sets the page configuration (optional). If an individual parameter is\n\
5671 zero then that parameter value is not updated. Not all parameters are\n\
5672 recognized by all drivers and the interpretation is device-dependent.\n\
5673 The X-window driver uses the length and offset parameters to determine\n\
5674 the window size and location. The length and offset values are\n\
5675 expressed in units that are specific to the current driver. For\n\
5676 instance: screen drivers will usually interpret them as number of\n\
5677 pixels, whereas printer drivers will usually use mm. This routine, if\n\
5678 used, must be called before initializing PLplot. \n\
5679 \n\
5680 Redacted form: plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5681 \n\
5682 This function is used in examples 14 and 31. \n\
5683 \n\
5684 \n\
5685 \n\
5686 SYNOPSIS:\n\
5687 \n\
5688 plspage(xp, yp, xleng, yleng, xoff, yoff)\n\
5689 \n\
5690 ARGUMENTS:\n\
5691 \n\
5692 xp (PLFLT, input) : Number of pixels/inch (DPI), x. \n\
5693 \n\
5694 yp (PLFLT, input) : Number of pixels/inch (DPI), y. \n\
5695 \n\
5696 xleng (PLINT , input) : Page length, x. \n\
5697 \n\
5698 yleng (PLINT, input) : Page length, y. \n\
5699 \n\
5700 xoff (PLINT, input) : Page offset, x. \n\
5701 \n\
5702 yoff (PLINT, input) : Page offset, y. \n\
5703 ";
5704 const char* _wrap_plprec_texinfo = "-*- texinfo -*-\n\
5705 Set precision in numeric labels \n\
5706 \n\
5707 DESCRIPTION:\n\
5708 \n\
5709 Sets the number of places after the decimal point in numeric labels. \n\
5710 \n\
5711 Redacted form: plprec(set, prec)\n\
5712 \n\
5713 This function is used in example 29. \n\
5714 \n\
5715 \n\
5716 \n\
5717 SYNOPSIS:\n\
5718 \n\
5719 plprec(set, prec)\n\
5720 \n\
5721 ARGUMENTS:\n\
5722 \n\
5723 set (PLINT, input) : If set is equal to 0 then PLplot automatically\n\
5724 determines the number of places to use after the decimal point in\n\
5725 numeric labels (like those used to label axes). If set is 1 then\n\
5726 prec sets the number of places. \n\
5727 \n\
5728 prec (PLINT, input) : The number of characters to draw after the\n\
5729 decimal point in numeric labels. \n\
5730 ";
5731 const char* _wrap_plcpstrm_texinfo = "-*- texinfo -*-\n\
5732 Copy state parameters from the reference stream to the current stream \n\
5733 \n\
5734 DESCRIPTION:\n\
5735 \n\
5736 Copies state parameters from the reference stream to the current\n\
5737 stream. Tell driver interface to map device coordinates unless flags\n\
5738 == 1. \n\
5739 \n\
5740 This function is used for making save files of selected plots (e.g.\n\
5741 from the TK driver). After initializing, you can get a copy of the\n\
5742 current plot to the specified device by switching to this stream and\n\
5743 issuing a plcpstrm and a plreplot, with calls to plbop and pleop as\n\
5744 appropriate. The plot buffer must have previously been enabled (done\n\
5745 automatically by some display drivers, such as X). \n\
5746 \n\
5747 Redacted form: plcpstrm(iplsr, flags)\n\
5748 \n\
5749 This function is used in example 1,20. \n\
5750 \n\
5751 \n\
5752 \n\
5753 SYNOPSIS:\n\
5754 \n\
5755 plcpstrm(iplsr, flags)\n\
5756 \n\
5757 ARGUMENTS:\n\
5758 \n\
5759 iplsr (PLINT, input) : Number of reference stream. \n\
5760 \n\
5761 flags (PLBOOL, input) : If flags is set to true the device\n\
5762 coordinates are not copied from the reference to current stream. \n\
5763 ";
5764 const char* _wrap_plpoin_texinfo = "-*- texinfo -*-\n\
5765 Plot a glyph at the specified points \n\
5766 \n\
5767 DESCRIPTION:\n\
5768 \n\
5769 Plot a glyph at the specified points. (This function is largely\n\
5770 superseded by plstring which gives access to many[!] more glyphs.)\n\
5771 code=-1 means try to just draw a point. Right now it\'s just a move\n\
5772 and a draw at the same place. Not ideal, since a sufficiently\n\
5773 intelligent output device may optimize it away, or there may be faster\n\
5774 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
5775 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
5776 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
5777 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
5778 code <= 127 the corresponding printable ASCII character is plotted. \n\
5779 \n\
5780 Redacted form: plpoin(x, y, code)\n\
5781 \n\
5782 This function is used in examples 1,6,14,29. \n\
5783 \n\
5784 \n\
5785 \n\
5786 SYNOPSIS:\n\
5787 \n\
5788 plpoin(n, x, y, code)\n\
5789 \n\
5790 ARGUMENTS:\n\
5791 \n\
5792 n (PLINT, input) : Number of points in the x and y arrays. \n\
5793 \n\
5794 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
5795 points. \n\
5796 \n\
5797 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
5798 points. \n\
5799 \n\
5800 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
5801 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
5802 each of the n points. \n\
5803 ";
5804 const char* _wrap_plxormod_texinfo = "-*- texinfo -*-\n\
5805 Enter or leave xor mode \n\
5806 \n\
5807 DESCRIPTION:\n\
5808 \n\
5809 Enter (when mode is true) or leave (when mode is false) xor mode for\n\
5810 those drivers (e.g., the xwin driver) that support it. Enables\n\
5811 erasing plots by drawing twice the same line, symbol, etc.\tIf driver\n\
5812 is not capable of xor operation it returns a status of false. \n\
5813 \n\
5814 Redacted form: plxormod(mode, status)\n\
5815 \n\
5816 This function is used in examples 1,20. \n\
5817 \n\
5818 \n\
5819 \n\
5820 SYNOPSIS:\n\
5821 \n\
5822 plxormod(mode, status)\n\
5823 \n\
5824 ARGUMENTS:\n\
5825 \n\
5826 mode (PLBOOL, input) : mode is true means enter xor mode and mode\n\
5827 is false means leave xor mode. \n\
5828 \n\
5829 status (PLBOOL *, output) : Pointer to status. Returned modestatus\n\
5830 of true (false) means driver is capable (incapable) of xor mode. \n\
5831 ";
5832 const char* _wrap_plgvpd_texinfo = "-*- texinfo -*-\n\
5833 Get viewport limits in normalized device coordinates \n\
5834 \n\
5835 DESCRIPTION:\n\
5836 \n\
5837 Get viewport limits in normalized device coordinates. \n\
5838 \n\
5839 Redacted form: General: plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5840 \t Perl/PDL: Not available? \n\
5841 \n\
5842 \n\
5843 This function is used in example 31. \n\
5844 \n\
5845 \n\
5846 \n\
5847 SYNOPSIS:\n\
5848 \n\
5849 plgvpd(p_xmin, p_xmax, p_ymin, p_ymax)\n\
5850 \n\
5851 ARGUMENTS:\n\
5852 \n\
5853 p_xmin (PLFLT *, output) : Lower viewport limit of the normalized\n\
5854 device coordinate in x. \n\
5855 \n\
5856 p_xmax (PLFLT *, output) : Upper viewport limit of the normalized\n\
5857 device coordinate in x. \n\
5858 \n\
5859 p_ymin (PLFLT *, output) : Lower viewport limit of the normalized\n\
5860 device coordinate in y. \n\
5861 \n\
5862 p_ymax (PLFLT *, output) : Upper viewport limit of the normalized\n\
5863 device coordinate in y. \n\
5864 ";
5865 const char* _wrap_plend1_texinfo = "-*- texinfo -*-\n\
5866 End plotting session for current stream \n\
5867 \n\
5868 DESCRIPTION:\n\
5869 \n\
5870 Ends a plotting session for the current output stream only. See\n\
5871 plsstrm for more info. \n\
5872 \n\
5873 Redacted form: plend1()\n\
5874 \n\
5875 This function is used in examples 1,20. \n\
5876 \n\
5877 \n\
5878 \n\
5879 SYNOPSIS:\n\
5880 \n\
5881 plend1()\n\
5882 ";
5883 const char* _wrap_plgyax_texinfo = "-*- texinfo -*-\n\
5884 Get y axis parameters \n\
5885 \n\
5886 DESCRIPTION:\n\
5887 \n\
5888 Identical to plgxax, except that arguments are flags for y axis. See\n\
5889 the description of plgxax for more detail. \n\
5890 \n\
5891 Redacted form: plgyax(digmax, digits)\n\
5892 \n\
5893 This function is used in example 31. \n\
5894 \n\
5895 \n\
5896 \n\
5897 SYNOPSIS:\n\
5898 \n\
5899 plgyax(digmax, digits)\n\
5900 \n\
5901 ARGUMENTS:\n\
5902 \n\
5903 digmax (PLINT *, output) : Pointer to variable with the maximum\n\
5904 number of digits for the y axis. If nonzero, the printed label\n\
5905 has been switched to a floating point representation when the\n\
5906 number of digits exceeds digmax. \n\
5907 \n\
5908 digits (PLINT *, output) : Pointer to variable with the actual\n\
5909 number of digits for the numeric labels (y axis) from the last\n\
5910 plot. \n\
5911 ";
5912 const char* _wrap_plsdiori_texinfo = "-*- texinfo -*-\n\
5913 Set plot orientation \n\
5914 \n\
5915 DESCRIPTION:\n\
5916 \n\
5917 Set plot orientation parameter which is multiplied by 90 degrees to\n\
5918 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
5919 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
5920 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
5921 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
5922 (seascape mode), and 270 degrees (upside-down mode). If plsdiori is\n\
5923 not called the default value of rot is 0. \n\
5924 \n\
5925 N.B. aspect ratio is unaffected by calls to plsdiori. So you will\n\
5926 probably want to change the aspect ratio to a value suitable for the\n\
5927 plot orientation using a call to plsdidev or the command-line options\n\
5928 -a or -freeaspect.\tFor more documentation of those options see the\n\
5929 PLplot documentation. Such command-line options can be set internally\n\
5930 using plsetopt or set directly using the command line and parsed using\n\
5931 a call to plparseopts. \n\
5932 \n\
5933 Redacted form: plsdiori(rot)\n\
5934 \n\
5935 This function is not used in any examples. \n\
5936 \n\
5937 \n\
5938 \n\
5939 SYNOPSIS:\n\
5940 \n\
5941 plsdiori(rot)\n\
5942 \n\
5943 ARGUMENTS:\n\
5944 \n\
5945 rot (PLFLT, input) : Plot orientation parameter. \n\
5946 ";
5947 const char* _wrap_plhist_texinfo = "-*- texinfo -*-\n\
5948 Plot a histogram from unbinned data \n\
5949 \n\
5950 DESCRIPTION:\n\
5951 \n\
5952 Plots a histogram from n data points stored in the array data. This\n\
5953 routine bins the data into nbin bins equally spaced between datmin and\n\
5954 datmax, and calls plbin to draw the resulting histogram. Parameter\n\
5955 opt allows, among other things, the histogram either to be plotted in\n\
5956 an existing window or causes plhist to call plenv with suitable limits\n\
5957 before plotting the histogram. \n\
5958 \n\
5959 Redacted form: plhist(data, datmin, datmax, nbin, opt)\n\
5960 \n\
5961 This function is used in example 5. \n\
5962 \n\
5963 \n\
5964 \n\
5965 SYNOPSIS:\n\
5966 \n\
5967 plhist(n, data, datmin, datmax, nbin, opt)\n\
5968 \n\
5969 ARGUMENTS:\n\
5970 \n\
5971 n (PLINT, input) : Number of data points. \n\
5972 \n\
5973 data (PLFLT *, input) : Pointer to array with values of the n data\n\
5974 points. \n\
5975 \n\
5976 datmin (PLFLT, input) : Left-hand edge of lowest-valued bin. \n\
5977 \n\
5978 datmax (PLFLT, input) : Right-hand edge of highest-valued bin. \n\
5979 \n\
5980 nbin (PLINT, input) : Number of (equal-sized) bins into which to\n\
5981 divide the interval xmin to xmax. \n\
5982 \n\
5983 opt (PLINT, input) : Is a combination of several flags:\n\
5984 opt=PL_HIST_DEFAULT: The axes are automatically rescaled to fit\n\
5985 the histogram data, the outer bins are expanded to fill up the\n\
5986 entire x-axis, data outside the given extremes are assigned to the\n\
5987 outer bins and bins of zero height are simply drawn. \n\
5988 opt=PL_HIST_NOSCALING|...: The existing axes are not rescaled\n\
5989 to fit the histogram data, without this flag, plenv is called\n\
5990 to set the world coordinates. \n\
5991 opt=PL_HIST_IGNORE_OUTLIERS|...: Data outside the given\n\
5992 extremes are not taken into account. This option should\n\
5993 probably be combined with opt=PL_HIST_NOEXPAND|..., so as to\n\
5994 properly present the data. \n\
5995 opt=PL_HIST_NOEXPAND|...: The outer bins are drawn with equal\n\
5996 size as the ones inside. \n\
5997 opt=PL_HIST_NOEMPTY|...: Bins with zero height are not drawn\n\
5998 (there is a gap for such bins). \n\
5999 ";
6000 const char* _wrap_plend_texinfo = "-*- texinfo -*-\n\
6001 End plotting session \n\
6002 \n\
6003 DESCRIPTION:\n\
6004 \n\
6005 Ends a plotting session, tidies up all the output files, switches\n\
6006 interactive devices back into text mode and frees up any memory that\n\
6007 was allocated. Must be called before end of program. \n\
6008 \n\
6009 By default, PLplot\'s interactive devices (Xwin, TK, etc.) go into a\n\
6010 wait state after a call to plend or other functions which trigger the\n\
6011 end of a plot page. To avoid this, use the plspause function. \n\
6012 \n\
6013 Redacted form: plend()\n\
6014 \n\
6015 This function is used in all of the examples. \n\
6016 \n\
6017 \n\
6018 \n\
6019 SYNOPSIS:\n\
6020 \n\
6021 plend()\n\
6022 ";
6023 const char* _wrap_plscompression_texinfo = "-*- texinfo -*-\n\
6024 Set device-compression level \n\
6025 \n\
6026 DESCRIPTION:\n\
6027 \n\
6028 Set device-compression level. Only used for drivers that provide\n\
6029 compression. This function, if used, should be invoked before a call\n\
6030 to plinit.\t\n\
6031 \n\
6032 Redacted form: plscompression(compression)\n\
6033 \n\
6034 This function is used in example 31. \n\
6035 \n\
6036 \n\
6037 \n\
6038 SYNOPSIS:\n\
6039 \n\
6040 plscompression(compression)\n\
6041 \n\
6042 ARGUMENTS:\n\
6043 \n\
6044 compression (PLINT, input) : The desired compression level. This is\n\
6045 a device-dependent value. Currently only the jpeg and png devices\n\
6046 use these values. For jpeg value is the jpeg quality which should\n\
6047 normally be in the range 0-95. Higher values denote higher quality\n\
6048 and hence larger image sizes. For png values are in the range -1\n\
6049 to 99. Values of 0-9 are taken as the compression level for zlib.\n\
6050 A value of -1 denotes the default zlib compression level. Values\n\
6051 in the range 10-99 are divided by 10 and then used as the zlib\n\
6052 compression level. Higher compression levels correspond to greater\n\
6053 compression and small file sizes at the expense of more\n\
6054 computation. \n\
6055 ";
6056 const char* _wrap_plgcompression_texinfo = "-*- texinfo -*-\n\
6057 Get the current device-compression setting \n\
6058 \n\
6059 DESCRIPTION:\n\
6060 \n\
6061 Get the current device-compression setting. This parameter is only\n\
6062 used for drivers that provide compression. \n\
6063 \n\
6064 Redacted form: plgcompression(compression)\n\
6065 \n\
6066 This function is used in example 31. \n\
6067 \n\
6068 \n\
6069 \n\
6070 SYNOPSIS:\n\
6071 \n\
6072 plgcompression(compression)\n\
6073 \n\
6074 ARGUMENTS:\n\
6075 \n\
6076 compression (PLINT *, output) : Pointer to a variable to be filled\n\
6077 with the current device-compression setting. \n\
6078 ";
6079 const char* _wrap_pladv_texinfo = "-*- texinfo -*-\n\
6080 Advance the (sub-)page\n\
6081 \n\
6082 DESCRIPTION:\n\
6083 \n\
6084 Advances to the next subpage if sub=0, performing a page advance if\n\
6085 there are no remaining subpages on the current page. If subpages\n\
6086 aren\'t being used, pladv(0) will always advance the page. If sub>0,\n\
6087 PLplot switches to the specified subpage. Note that this allows you\n\
6088 to overwrite a plot on the specified subpage; if this is not what you\n\
6089 intended, use pleop followed by plbop to first advance the page. This\n\
6090 routine is called automatically (with sub=0) by plenv, but if plenv is\n\
6091 not used, pladv must be called after initializing PLplot but before\n\
6092 defining the viewport. \n\
6093 \n\
6094 Redacted form: pladv(sub)\n\
6095 \n\
6096 This function is used in examples 1,2,4,6-12,14-18,20,21,23-27,29,31. \n\
6097 \n\
6098 \n\
6099 \n\
6100 SYNOPSIS:\n\
6101 \n\
6102 pladv(sub)\n\
6103 \n\
6104 ARGUMENTS:\n\
6105 \n\
6106 sub (PLINT, input) : Specifies the subpage number (starting from 1\n\
6107 in the top left corner and increasing along the rows) to which to\n\
6108 advance. Set to zero to advance to the next subpage. \n\
6109 ";
6110 const char* _wrap_pl_setcontlabelparam_texinfo = "-*- texinfo -*-\n\
6111 Set parameters of contour labelling other than format of numerical label\n\
6112 \n\
6113 DESCRIPTION:\n\
6114 \n\
6115 Set parameters of contour labelling other than those handled by\n\
6116 pl_setcontlabelformat. \n\
6117 \n\
6118 Redacted form: pl_setcontlabelparam(offset, size, spacing, active)\n\
6119 \n\
6120 This function is used in example 9. \n\
6121 \n\
6122 \n\
6123 \n\
6124 SYNOPSIS:\n\
6125 \n\
6126 pl_setcontlabelparam(offset, size, spacing, active)\n\
6127 \n\
6128 ARGUMENTS:\n\
6129 \n\
6130 offset (PLFLT, input) : Offset of label from contour line (if set\n\
6131 to 0.0, labels are printed on the lines). Default value is 0.006. \n\
6132 \n\
6133 size (PLFLT, input) : Font height for contour labels (normalized). \n\
6134 Default value is 0.3. \n\
6135 \n\
6136 spacing (PLFLT, input) : Spacing parameter for contour labels. \n\
6137 Default value is 0.1. \n\
6138 \n\
6139 active (PLINT, input) : Activate labels. Set to 1 if you want\n\
6140 contour labels on. Default is off (0). \n\
6141 ";
6142 const char* _wrap_plsfont_texinfo = "-*- texinfo -*-\n\
6143 Set family, style and weight of the current font \n\
6144 \n\
6145 DESCRIPTION:\n\
6146 \n\
6147 Sets the current font. See the PLplot documentation for more\n\
6148 information on font selection. \n\
6149 \n\
6150 Redacted form: plsfont(family, style, weight)\n\
6151 \n\
6152 This function is used in example 23. \n\
6153 \n\
6154 \n\
6155 \n\
6156 SYNOPSIS:\n\
6157 \n\
6158 plsfont(family, style, weight)\n\
6159 \n\
6160 ARGUMENTS:\n\
6161 \n\
6162 family (PLINT, input) : Font family to select for the current font.\n\
6163 The available values are given by the PL_FCI_* constants in\n\
6164 plplot.h. Current options are PL_FCI_SANS, PL_FCI_SERIF, \n\
6165 PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. A negative value\n\
6166 signifies that the font family should not be altered. \n\
6167 \n\
6168 style (PLINT, input) : Font style to select for the current font.\n\
6169 The available values are given by the PL_FCI_* constants in\n\
6170 plplot.h. Current options are PL_FCI_UPRIGHT, PL_FCI_ITALIC and\n\
6171 PL_FCI_OBLIQUE. A negative value signifies that the font style\n\
6172 should not be altered. \n\
6173 \n\
6174 weight (PLINT, input) : Font weight to select for the current font.\n\
6175 The available values are given by the PL_FCI_* constants in\n\
6176 plplot.h. Current options are PL_FCI_MEDIUM and PL_FCI_BOLD. A\n\
6177 negative value signifies that the font weight should not be\n\
6178 altered. \n\
6179 ";
6180 const char* _wrap_pllightsource_texinfo = "-*- texinfo -*-\n\
6181 Sets the 3D position of the light source \n\
6182 \n\
6183 DESCRIPTION:\n\
6184 \n\
6185 Sets the 3D position of the light source for use with plsurf3d. \n\
6186 \n\
6187 Redacted form: pllightsource(x, y, z)\n\
6188 \n\
6189 This function is used in example 8. \n\
6190 \n\
6191 \n\
6192 \n\
6193 SYNOPSIS:\n\
6194 \n\
6195 pllightsource(x, y, z)\n\
6196 \n\
6197 ARGUMENTS:\n\
6198 \n\
6199 x (PLFLT, input) : X-coordinate of the light source. \n\
6200 \n\
6201 y (PLFLT, input) : Y-coordinate of the light source. \n\
6202 \n\
6203 z (PLFLT, input) : Z-coordinate of the light source. \n\
6204 ";
6205 const char* _wrap_plline_texinfo = "-*- texinfo -*-\n\
6206 Draw a line \n\
6207 \n\
6208 DESCRIPTION:\n\
6209 \n\
6210 Draws line defined by n points in x and y. \n\
6211 \n\
6212 Redacted form: plline(x, y)\n\
6213 \n\
6214 This function is used in examples 1,3,4,9,12-14,16,18,20,22,25-27,29. \n\
6215 \n\
6216 \n\
6217 \n\
6218 SYNOPSIS:\n\
6219 \n\
6220 plline(n, x, y)\n\
6221 \n\
6222 ARGUMENTS:\n\
6223 \n\
6224 n (PLINT, input) : Number of points defining line. \n\
6225 \n\
6226 x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
6227 \n\
6228 y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
6229 ";
6230 const char* _wrap_plwidth_texinfo = "-*- texinfo -*-\n\
6231 Set pen width \n\
6232 \n\
6233 DESCRIPTION:\n\
6234 \n\
6235 Sets the pen width. \n\
6236 \n\
6237 Redacted form: plwidth(width)\n\
6238 \n\
6239 This function is used in examples 1,2. \n\
6240 \n\
6241 \n\
6242 \n\
6243 SYNOPSIS:\n\
6244 \n\
6245 plwidth(width)\n\
6246 \n\
6247 ARGUMENTS:\n\
6248 \n\
6249 width (PLFLT, input) : The desired pen width. If width is negative\n\
6250 or the same as the previous value no action is taken. width = 0.\n\
6251 should be interpreted as as the minimum valid pen width for the\n\
6252 device. The interpretation of positive width values is also\n\
6253 device dependent. \n\
6254 ";
6255 const char* _wrap_plgradient_texinfo = "-*- texinfo -*-\n\
6256 Draw linear gradient inside polygon \n\
6257 \n\
6258 DESCRIPTION:\n\
6259 \n\
6260 Draw a linear gradient using colour map 1 inside the polygon defined\n\
6261 by the n points (\n\
6262 x[i], \n\
6263 y[i]). Interpretation of the polygon is the same as for plfill. The\n\
6264 polygon coordinates and the gradient angle are all expressed in world\n\
6265 coordinates. The angle from the x axis for both the rotated\n\
6266 coordinate system and the gradient vector is specified by angle. The\n\
6267 magnitude of the gradient vector is the difference between the maximum\n\
6268 and minimum values of x for the vertices in the rotated coordinate\n\
6269 system. The origin of the gradient vector can be interpreted as being\n\
6270 anywhere on the line corresponding to the minimum x value for the\n\
6271 vertices in the rotated coordinate system.\tThe distance along the\n\
6272 gradient vector is linearly transformed to the independent variable of\n\
6273 colour map 1 which ranges from 0. at the tail of the gradient vector\n\
6274 to 1. at the head of the gradient vector. What is drawn is the RGBA\n\
6275 colour corresponding to the independent variable of colour map 1. For\n\
6276 more information about colour map 1 (see the PLplot documentation). \n\
6277 \n\
6278 Redacted form: plgradient(x,y,angle)\n\
6279 \n\
6280 This function is used in examples 25,30. \n\
6281 \n\
6282 \n\
6283 \n\
6284 SYNOPSIS:\n\
6285 \n\
6286 plgradient(n, x, y, angle)\n\
6287 \n\
6288 ARGUMENTS:\n\
6289 \n\
6290 n (PLINT, input) : Number of vertices in polygon. \n\
6291 \n\
6292 x (PLFLT *, input) : Pointer to array with x coordinates of\n\
6293 vertices. \n\
6294 \n\
6295 y (PLFLT *, input) : Pointer to array with y coordinates of\n\
6296 vertices. \n\
6297 \n\
6298 angle (PLFLT, input) : Angle (degrees) of gradient vector from x\n\
6299 axis. \n\
6300 ";
6301 const char* _wrap_plflush_texinfo = "-*- texinfo -*-\n\
6302 Flushes the output stream \n\
6303 \n\
6304 DESCRIPTION:\n\
6305 \n\
6306 Flushes the output stream. Use sparingly, if at all. \n\
6307 \n\
6308 Redacted form: plflush()\n\
6309 \n\
6310 This function is used in examples 1,14. \n\
6311 \n\
6312 \n\
6313 \n\
6314 SYNOPSIS:\n\
6315 \n\
6316 plflush()\n\
6317 ";
6318 const char* _wrap_plgdiori_texinfo = "-*- texinfo -*-\n\
6319 Get plot orientation \n\
6320 \n\
6321 DESCRIPTION:\n\
6322 \n\
6323 Get plot orientation parameter which is multiplied by 90 degrees to\n\
6324 obtain the angle of rotation. Note, arbitrary rotation parameters\n\
6325 such as 0.2 (corresponding to 18 degrees) are possible, but the usual\n\
6326 values for the rotation parameter are 0., 1., 2., and 3. corresponding\n\
6327 to 0 degrees (landscape mode), 90 degrees (portrait mode), 180 degrees\n\
6328 (seascape mode), and 270 degrees (upside-down mode). If plsdiori has\n\
6329 not been called the default value pointed to by p_rot will be 0. \n\
6330 \n\
6331 Redacted form: plgdiori(p_rot)\n\
6332 \n\
6333 This function is not used in any examples. \n\
6334 \n\
6335 \n\
6336 \n\
6337 SYNOPSIS:\n\
6338 \n\
6339 plgdiori(p_rot)\n\
6340 \n\
6341 ARGUMENTS:\n\
6342 \n\
6343 p_rot (PLFLT *, output) : Pointer to orientation parameter. \n\
6344 ";
6345 const char* _wrap_plsxax_texinfo = "-*- texinfo -*-\n\
6346 Set x axis parameters \n\
6347 \n\
6348 DESCRIPTION:\n\
6349 \n\
6350 Sets values of the digmax and digits flags for the x axis.\tSee the\n\
6351 PLplot documentation for more information. \n\
6352 \n\
6353 Redacted form: plsxax(digmax, digits)\n\
6354 \n\
6355 This function is used in example 31. \n\
6356 \n\
6357 \n\
6358 \n\
6359 SYNOPSIS:\n\
6360 \n\
6361 plsxax(digmax, digits)\n\
6362 \n\
6363 ARGUMENTS:\n\
6364 \n\
6365 digmax (PLINT, input) : Variable to set the maximum number of\n\
6366 digits for the x axis. If nonzero, the printed label will be\n\
6367 switched to a floating point representation when the number of\n\
6368 digits exceeds digmax. \n\
6369 \n\
6370 digits (PLINT, input) : Field digits value. Currently, changing\n\
6371 its value here has no effect since it is set only by plbox or\n\
6372 plbox3. However, the user may obtain its value after a call to\n\
6373 either of these functions by calling plgxax. \n\
6374 ";
6375 const char* _wrap_plgvpw_texinfo = "-*- texinfo -*-\n\
6376 Get viewport limits in world coordinates \n\
6377 \n\
6378 DESCRIPTION:\n\
6379 \n\
6380 Get viewport limits in world coordinates. \n\
6381 \n\
6382 Redacted form: General: plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6383 \t Perl/PDL: Not available? \n\
6384 \n\
6385 \n\
6386 This function is used in example 31. \n\
6387 \n\
6388 \n\
6389 \n\
6390 SYNOPSIS:\n\
6391 \n\
6392 plgvpw(p_xmin, p_xmax, p_ymin, p_ymax)\n\
6393 \n\
6394 ARGUMENTS:\n\
6395 \n\
6396 p_xmin (PLFLT *, output) : Lower viewport limit of the world\n\
6397 coordinate in x. \n\
6398 \n\
6399 p_xmax (PLFLT *, output) : Upper viewport limit of the world\n\
6400 coordinate in x. \n\
6401 \n\
6402 p_ymin (PLFLT *, output) : Lower viewport limit of the world\n\
6403 coordinate in y. \n\
6404 \n\
6405 p_ymax (PLFLT *, output) : Upper viewport limit of the world\n\
6406 coordinate in y. \n\
6407 ";
6408 const char* _wrap_plgspa_texinfo = "-*- texinfo -*-\n\
6409 Get current subpage parameters \n\
6410 \n\
6411 DESCRIPTION:\n\
6412 \n\
6413 Gets the size of the current subpage in millimeters measured from the\n\
6414 bottom left hand corner of the output device page or screen. Can be\n\
6415 used in conjunction with plsvpa for setting the size of a viewport in\n\
6416 absolute coordinates (millimeters). \n\
6417 \n\
6418 Redacted form: plgspa(xmin, xmax, ymin, ymax)\n\
6419 \n\
6420 This function is used in example 23. \n\
6421 \n\
6422 \n\
6423 \n\
6424 SYNOPSIS:\n\
6425 \n\
6426 plgspa(xmin, xmax, ymin, ymax)\n\
6427 \n\
6428 ARGUMENTS:\n\
6429 \n\
6430 xmin (PLFLT *, output) : Pointer to variable with position of left\n\
6431 hand edge of subpage in millimeters. \n\
6432 \n\
6433 xmax (PLFLT *, output) : Pointer to variable with position of right\n\
6434 hand edge of subpage in millimeters. \n\
6435 \n\
6436 ymin (PLFLT *, output) : Pointer to variable with position of\n\
6437 bottom edge of subpage in millimeters. \n\
6438 \n\
6439 ymax (PLFLT *, output) : Pointer to variable with position of top\n\
6440 edge of subpage in millimeters. \n\
6441 ";
6442 const char* _wrap_plcalc_world_texinfo = "-*- texinfo -*-\n\
6443 Calculate world coordinates and corresponding window index from relative device coordinates \n\
6444 \n\
6445 DESCRIPTION:\n\
6446 \n\
6447 Calculate world coordinates, wx and wy, and corresponding window index\n\
6448 from relative device coordinates, rx and ry. \n\
6449 \n\
6450 Redacted form: General: plcalc_world(rx, ry, wx, wy, window)\n\
6451 \t Perl/PDL: Not available? \n\
6452 \n\
6453 \n\
6454 This function is used in example 31. \n\
6455 \n\
6456 \n\
6457 \n\
6458 SYNOPSIS:\n\
6459 \n\
6460 plcalc_world(rx, ry, wx, wy, window)\n\
6461 \n\
6462 ARGUMENTS:\n\
6463 \n\
6464 rx (PLFLT, input) : Input relative device coordinate (ranging from\n\
6465 0. to 1.) for the x coordinate. \n\
6466 \n\
6467 ry (PLFLT, input) : Input relative device coordinate (ranging from\n\
6468 0. to 1.) for the y coordinate. \n\
6469 \n\
6470 wx (PLFLT *, output) : Pointer to the returned world coordinate for\n\
6471 x corresponding to the relative device coordinates rx and ry. \n\
6472 \n\
6473 wy (PLFLT *, output) : Pointer to the returned world coordinate for\n\
6474 y corresponding to the relative device coordinates rx and ry. \n\
6475 \n\
6476 window (PLINT *, output) : Pointer to the returned last defined\n\
6477 window index that corresponds to the input relative device\n\
6478 coordinates (and the returned world coordinates). To give some\n\
6479 background on the window index, for each page the initial window\n\
6480 index is set to zero, and each time plwind is called within the\n\
6481 page, world and device coordinates are stored for the window and\n\
6482 the window index is incremented. Thus, for a simple page layout\n\
6483 with non-overlapping viewports and one window per viewport, window\n\
6484 corresponds to the viewport index (in the order which the\n\
6485 viewport/windows were created) of the only viewport/window\n\
6486 corresponding to rx and ry. However, for more complicated layouts\n\
6487 with potentially overlapping viewports and possibly more than one\n\
6488 window (set of world coordinates) per viewport, window and the\n\
6489 corresponding output world coordinates corresponds to the last\n\
6490 window created that fulfills the criterion that the relative\n\
6491 device coordinates are inside it. Finally, in all cases where the\n\
6492 input relative device coordinates are not inside any\n\
6493 viewport/window, then window is set to -1. \n\
6494 ";
6495 const char* _wrap_plbox3_texinfo = "-*- texinfo -*-\n\
6496 Draw a box with axes, etc, in 3-d \n\
6497 \n\
6498 DESCRIPTION:\n\
6499 \n\
6500 Draws axes, numeric and text labels for a three-dimensional surface\n\
6501 plot. For a more complete description of three-dimensional plotting\n\
6502 see the PLplot documentation. \n\
6503 \n\
6504 Redacted form: General: plbox3(xopt, xlabel, xtick, nxsub, yopt,\n\
6505 ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6506 \t Perl/PDL: plbox3(xtick, nxsub, ytick, nysub, ztick, nzsub,\n\
6507 xopt, xlabel, yopt, ylabel, zopt, zlabel)\n\
6508 \n\
6509 \n\
6510 This function is used in examples 8,11,18,21. \n\
6511 \n\
6512 \n\
6513 \n\
6514 SYNOPSIS:\n\
6515 \n\
6516 plbox3(xopt, xlabel, xtick, nxsub, yopt, ylabel, ytick, nysub, zopt, zlabel, ztick, nzsub)\n\
6517 \n\
6518 ARGUMENTS:\n\
6519 \n\
6520 xopt (const char *, input) : Pointer to character string specifying\n\
6521 options for the x axis. The string can include any combination of\n\
6522 the following letters (upper or lower case) in any order: b: Draws\n\
6523 axis at base, at height z=\n\
6524 zmin where zmin is defined by call to plw3d. This character must be\n\
6525 specified in order to use any of the other options. \n\
6526 f: Always use fixed point numeric labels. \n\
6527 i: Inverts tick marks, so they are drawn downwards, rather\n\
6528 than upwards. \n\
6529 l: Labels axis logarithmically. This only affects the labels,\n\
6530 not the data, and so it is necessary to compute the logarithms\n\
6531 of data points before passing them to any of the drawing\n\
6532 routines. \n\
6533 n: Writes numeric labels at major tick intervals. \n\
6534 o: Use custom labelling function to generate axis label text. \n\
6535 The custom labelling function can be defined with the\n\
6536 plslabelfunc command. \n\
6537 s: Enables subticks between major ticks, only valid if t is\n\
6538 also specified. \n\
6539 t: Draws major ticks. \n\
6540 u: If this is specified, the text label for the axis is\n\
6541 written under the axis. \n\
6542 \n\
6543 \n\
6544 xlabel (const char *, input) : Pointer to character string\n\
6545 specifying text label for the x axis. It is only drawn if u is in\n\
6546 the xopt string. \n\
6547 \n\
6548 xtick (PLFLT, input) : World coordinate interval between major\n\
6549 ticks on the x axis. If it is set to zero, PLplot automatically\n\
6550 generates a suitable tick interval. \n\
6551 \n\
6552 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
6553 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6554 generates a suitable minor tick interval. \n\
6555 \n\
6556 yopt (const char *, input) : Pointer to character string specifying\n\
6557 options for the y axis. The string is interpreted in the same way\n\
6558 as xopt. \n\
6559 \n\
6560 ylabel (const char *, input) : Pointer to character string\n\
6561 specifying text label for the y axis. It is only drawn if u is in\n\
6562 the yopt string. \n\
6563 \n\
6564 ytick (PLFLT, input) : World coordinate interval between major\n\
6565 ticks on the y axis. If it is set to zero, PLplot automatically\n\
6566 generates a suitable tick interval. \n\
6567 \n\
6568 nysub (PLINT, input) : Number of subintervals between major y axis\n\
6569 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6570 generates a suitable minor tick interval. \n\
6571 \n\
6572 zopt (const char *, input) : Pointer to character string specifying\n\
6573 options for the z axis. The string can include any combination of\n\
6574 the following letters (upper or lower case) in any order: b: Draws\n\
6575 z axis to the left of the surface plot. \n\
6576 c: Draws z axis to the right of the surface plot. \n\
6577 d: Draws grid lines parallel to the x-y plane behind the\n\
6578 figure. These lines are not drawn until after plot3d or\n\
6579 plmesh are called because of the need for hidden line removal. \n\
6580 f: Always use fixed point numeric labels. \n\
6581 i: Inverts tick marks, so they are drawn away from the center. \n\
6582 l: Labels axis logarithmically. This only affects the labels,\n\
6583 not the data, and so it is necessary to compute the logarithms\n\
6584 of data points before passing them to any of the drawing\n\
6585 routines. \n\
6586 m: Writes numeric labels at major tick intervals on the\n\
6587 right-hand vertical axis. \n\
6588 n: Writes numeric labels at major tick intervals on the\n\
6589 left-hand vertical axis. \n\
6590 o: Use custom labelling function to generate axis label text. \n\
6591 The custom labelling function can be defined with the\n\
6592 plslabelfunc command. \n\
6593 s: Enables subticks between major ticks, only valid if t is\n\
6594 also specified. \n\
6595 t: Draws major ticks. \n\
6596 u: If this is specified, the text label is written beside the\n\
6597 left-hand axis. \n\
6598 v: If this is specified, the text label is written beside the\n\
6599 right-hand axis. \n\
6600 \n\
6601 \n\
6602 zlabel (const char *, input) : Pointer to character string\n\
6603 specifying text label for the z axis. It is only drawn if u or v\n\
6604 are in the zopt string. \n\
6605 \n\
6606 ztick (PLFLT, input) : World coordinate interval between major\n\
6607 ticks on the z axis. If it is set to zero, PLplot automatically\n\
6608 generates a suitable tick interval. \n\
6609 \n\
6610 nzsub (PLINT, input) : Number of subintervals between major z axis\n\
6611 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
6612 generates a suitable minor tick interval. \n\
6613 ";
6614 const char* _wrap_plgchr_texinfo = "-*- texinfo -*-\n\
6615 Get character default height and current (scaled) height \n\
6616 \n\
6617 DESCRIPTION:\n\
6618 \n\
6619 Get character default height and current (scaled) height. \n\
6620 \n\
6621 Redacted form: plgchr(p_def, p_ht)\n\
6622 \n\
6623 This function is used in example 23. \n\
6624 \n\
6625 \n\
6626 \n\
6627 SYNOPSIS:\n\
6628 \n\
6629 plgchr(p_def, p_ht)\n\
6630 \n\
6631 ARGUMENTS:\n\
6632 \n\
6633 p_def (PLFLT *, output) : Pointer to default character height (mm). \n\
6634 \n\
6635 p_ht (PLFLT *, output) : Pointer to current (scaled) character\n\
6636 height (mm). \n\
6637 ";
6638 const char* _wrap_plsesc_texinfo = "-*- texinfo -*-\n\
6639 Set the escape character for text strings \n\
6640 \n\
6641 DESCRIPTION:\n\
6642 \n\
6643 Set the escape character for text strings.\tFrom C (in contrast to\n\
6644 Fortran 95, see plsescfortran95) you pass esc as a character. Only\n\
6645 selected characters are allowed to prevent the user from shooting\n\
6646 himself in the foot (For example, a \\ isn\'t allowed since it conflicts\n\
6647 with C\'s use of backslash as a character escape). Here are the\n\
6648 allowed escape characters and their corresponding decimal ASCII\n\
6649 values: !, ASCII 33 \n\
6650 \t #, ASCII 35 \n\
6651 \t $, ASCII 36 \n\
6652 \t %, ASCII 37 \n\
6653 \t &, ASCII 38 \n\
6654 \t *, ASCII 42 \n\
6655 \t @, ASCII 64 \n\
6656 \t ^, ASCII 94 \n\
6657 \t ~, ASCII 126 \n\
6658 \n\
6659 \n\
6660 Redacted form: General: plsesc(esc)\n\
6661 \t Perl/PDL: Not available? \n\
6662 \n\
6663 \n\
6664 This function is used in example 29. \n\
6665 \n\
6666 \n\
6667 \n\
6668 SYNOPSIS:\n\
6669 \n\
6670 plsesc(esc)\n\
6671 \n\
6672 ARGUMENTS:\n\
6673 \n\
6674 esc (char, input) : Escape character. \n\
6675 ";
6676 const char* _wrap_plpath_texinfo = "-*- texinfo -*-\n\
6677 Draw a line between two points, accounting for coordinate transforms. \n\
6678 \n\
6679 DESCRIPTION:\n\
6680 \n\
6681 Joins the point (\n\
6682 x1, \n\
6683 y1) to (\n\
6684 x2, \n\
6685 y2). If a global coordinate transform is defined then the line is\n\
6686 broken in to n segments to approximate the path. If no transform is\n\
6687 defined then this simply acts like a call to pljoin. \n\
6688 \n\
6689 Redacted form: plpath(n,x1,y1,x2,y2)\n\
6690 \n\
6691 This function is used in example 22. \n\
6692 \n\
6693 \n\
6694 \n\
6695 SYNOPSIS:\n\
6696 \n\
6697 plpath(n, x1, y1, x2, y2)\n\
6698 \n\
6699 ARGUMENTS:\n\
6700 \n\
6701 n (PLINT, input) : number of points to use to approximate the path. \n\
6702 \n\
6703 x1 (PLFLT, input) : x coordinate of first point. \n\
6704 \n\
6705 y1 (PLFLT, input) : y coordinate of first point. \n\
6706 \n\
6707 x2 (PLFLT, input) : x coordinate of second point. \n\
6708 \n\
6709 y2 (PLFLT, input) : y coordinate of second point. \n\
6710 ";
6711 const char* _wrap_plenv_texinfo = "-*- texinfo -*-\n\
6712 Set up standard window and draw box \n\
6713 \n\
6714 DESCRIPTION:\n\
6715 \n\
6716 Sets up plotter environment for simple graphs by calling pladv and\n\
6717 setting up viewport and window to sensible default values.\tplenv\n\
6718 leaves enough room around most graphs for axis labels and a title.\n\
6719 When these defaults are not suitable, use the individual routines\n\
6720 plvpas, plvpor, or plvasp for setting up the viewport, plwind for\n\
6721 defining the window, and plbox for drawing the box. \n\
6722 \n\
6723 Redacted form: plenv(xmin, xmax, ymin, ymax, just, axis)\n\
6724 \n\
6725 This function is used in example 1,3,9,13,14,19-22,29. \n\
6726 \n\
6727 \n\
6728 \n\
6729 SYNOPSIS:\n\
6730 \n\
6731 plenv(xmin, xmax, ymin, ymax, just, axis)\n\
6732 \n\
6733 ARGUMENTS:\n\
6734 \n\
6735 xmin (PLFLT, input) : Value of x at left-hand edge of window (in\n\
6736 world coordinates). \n\
6737 \n\
6738 xmax (PLFLT, input) : Value of x at right-hand edge of window (in\n\
6739 world coordinates). \n\
6740 \n\
6741 ymin (PLFLT, input) : Value of y at bottom edge of window (in world\n\
6742 coordinates). \n\
6743 \n\
6744 ymax (PLFLT, input) : Value of y at top edge of window (in world\n\
6745 coordinates). \n\
6746 \n\
6747 just (PLINT, input) : Controls how the axes will be scaled: -1: the\n\
6748 scales will not be set, the user must set up the scale before\n\
6749 calling plenv using plsvpa, plvasp or other. \n\
6750 0: the x and y axes are scaled independently to use as much of\n\
6751 the screen as possible. \n\
6752 1: the scales of the x and y axes are made equal. \n\
6753 2: the axis of the x and y axes are made equal, and the plot\n\
6754 box will be square. \n\
6755 \n\
6756 \n\
6757 axis (PLINT, input) : Controls drawing of the box around the plot:\n\
6758 -2: draw no box, no tick marks, no numeric tick labels, no axes. \n\
6759 -1: draw box only. \n\
6760 0: draw box, ticks, and numeric tick labels. \n\
6761 1: also draw coordinate axes at x=0 and y=0. \n\
6762 2: also draw a grid at major tick positions in both\n\
6763 coordinates. \n\
6764 3: also draw a grid at minor tick positions in both\n\
6765 coordinates. \n\
6766 10: same as 0 except logarithmic x tick marks. (The x data\n\
6767 have to be converted to logarithms separately.) \n\
6768 11: same as 1 except logarithmic x tick marks. (The x data\n\
6769 have to be converted to logarithms separately.) \n\
6770 12: same as 2 except logarithmic x tick marks. (The x data\n\
6771 have to be converted to logarithms separately.) \n\
6772 13: same as 3 except logarithmic x tick marks. (The x data\n\
6773 have to be converted to logarithms separately.) \n\
6774 20: same as 0 except logarithmic y tick marks. (The y data\n\
6775 have to be converted to logarithms separately.) \n\
6776 21: same as 1 except logarithmic y tick marks. (The y data\n\
6777 have to be converted to logarithms separately.) \n\
6778 22: same as 2 except logarithmic y tick marks. (The y data\n\
6779 have to be converted to logarithms separately.) \n\
6780 23: same as 3 except logarithmic y tick marks. (The y data\n\
6781 have to be converted to logarithms separately.) \n\
6782 30: same as 0 except logarithmic x and y tick marks. (The x\n\
6783 and y data have to be converted to logarithms separately.) \n\
6784 31: same as 1 except logarithmic x and y tick marks. (The x\n\
6785 and y data have to be converted to logarithms separately.) \n\
6786 32: same as 2 except logarithmic x and y tick marks. (The x\n\
6787 and y data have to be converted to logarithms separately.) \n\
6788 33: same as 3 except logarithmic x and y tick marks. (The x\n\
6789 and y data have to be converted to logarithms separately.) \n\
6790 40: same as 0 except date / time x labels. \n\
6791 41: same as 1 except date / time x labels. \n\
6792 42: same as 2 except date / time x labels. \n\
6793 43: same as 3 except date / time x labels. \n\
6794 50: same as 0 except date / time y labels. \n\
6795 51: same as 1 except date / time y labels. \n\
6796 52: same as 2 except date / time y labels. \n\
6797 53: same as 3 except date / time y labels. \n\
6798 60: same as 0 except date / time x and y labels. \n\
6799 61: same as 1 except date / time x and y labels. \n\
6800 62: same as 2 except date / time x and y labels. \n\
6801 63: same as 3 except date / time x and y labels. \n\
6802 70: same as 0 except custom x and y labels. \n\
6803 71: same as 1 except custom x and y labels. \n\
6804 72: same as 2 except custom x and y labels. \n\
6805 73: same as 3 except custom x and y labels. \n\
6806 ";
6807 const char* _wrap_plclear_texinfo = "-*- texinfo -*-\n\
6808 Clear current (sub)page \n\
6809 \n\
6810 DESCRIPTION:\n\
6811 \n\
6812 Clears the current page, effectively erasing everything that have been\n\
6813 drawn. This command only works with interactive drivers; if the\n\
6814 driver does not support this, the page is filled with the background\n\
6815 color in use. If the current page is divided into subpages, only the\n\
6816 current subpage is erased.\tThe nth subpage can be selected with\n\
6817 pladv(n). \n\
6818 \n\
6819 Redacted form: General: plclear()\n\
6820 \t Perl/PDL: Not available? \n\
6821 \n\
6822 \n\
6823 This function is not used in any examples. \n\
6824 \n\
6825 \n\
6826 \n\
6827 SYNOPSIS:\n\
6828 \n\
6829 plclear()\n\
6830 ";
6831 const char* _wrap_plscmap0a_texinfo = "-*- texinfo -*-\n\
6832 Set color map0 colors by 8-bit RGB values and double alpha value. \n\
6833 \n\
6834 DESCRIPTION:\n\
6835 \n\
6836 Set color map0 colors using 8-bit RGB values (see the PLplot\n\
6837 documentation) and floating point alpha value. This sets the entire\n\
6838 color map -- only as many colors as specified will be allocated. \n\
6839 \n\
6840 This function is used in examples 30. \n\
6841 \n\
6842 \n\
6843 \n\
6844 SYNOPSIS:\n\
6845 \n\
6846 plscmap0a(r, g, b, a, ncol0)\n\
6847 \n\
6848 ARGUMENTS:\n\
6849 \n\
6850 r (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6851 integers (0-255) representing the degree of red in the color. \n\
6852 \n\
6853 g (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6854 integers (0-255) representing the degree of green in the color. \n\
6855 \n\
6856 b (PLINT *, input) : Pointer to array with set of unsigned 8-bit\n\
6857 integers (0-255) representing the degree of blue in the color. \n\
6858 \n\
6859 a (PLFLT *, input) : Pointer to array with set of PLFLT values (0.0\n\
6860 - 1.0) representing the transparency of the color. \n\
6861 \n\
6862 ncol0 (PLINT, input) : Number of items in the r, g, b, and a\n\
6863 arrays. \n\
6864 ";
6865 const char* _wrap_plscol0_texinfo = "-*- texinfo -*-\n\
6866 Set a given color from color map0 by 8 bit RGB value \n\
6867 \n\
6868 DESCRIPTION:\n\
6869 \n\
6870 Set a given color by 8-bit RGB value for color map0 (see the PLplot\n\
6871 documentation). Overwrites the previous color value for the given\n\
6872 index and, thus, does not result in any additional allocation of space\n\
6873 for colors. \n\
6874 \n\
6875 Redacted form: plscol0(icol0, r, g, b)\n\
6876 \n\
6877 This function is used in any example 31. \n\
6878 \n\
6879 \n\
6880 \n\
6881 SYNOPSIS:\n\
6882 \n\
6883 plscol0(icol0, r, g, b)\n\
6884 \n\
6885 ARGUMENTS:\n\
6886 \n\
6887 icol0 (PLINT, input) : Color index. Must be less than the maximum\n\
6888 number of colors (which is set by default, by plscmap0n, or even\n\
6889 by plscmap0). \n\
6890 \n\
6891 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6892 degree of red in the color. \n\
6893 \n\
6894 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6895 degree of green in the color. \n\
6896 \n\
6897 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
6898 degree of blue in the color. \n\
6899 ";
6900 const char* _wrap_plsdimap_texinfo = "-*- texinfo -*-\n\
6901 Set up transformation from metafile coordinates \n\
6902 \n\
6903 DESCRIPTION:\n\
6904 \n\
6905 Set up transformation from metafile coordinates. The size of the plot\n\
6906 is scaled so as to preserve aspect ratio. This isn\'t intended to be a\n\
6907 general-purpose facility just yet (not sure why the user would need\n\
6908 it, for one). \n\
6909 \n\
6910 Redacted form: plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm,\n\
6911 dimypmm)\n\
6912 \n\
6913 This function is not used in any examples. \n\
6914 \n\
6915 \n\
6916 \n\
6917 SYNOPSIS:\n\
6918 \n\
6919 plsdimap(dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm)\n\
6920 \n\
6921 ARGUMENTS:\n\
6922 \n\
6923 dimxmin (PLINT, input) : NEEDS DOCUMENTATION \n\
6924 \n\
6925 dimxmax (PLINT, input) : NEEDS DOCUMENTATION \n\
6926 \n\
6927 dimymin (PLINT, input) : NEEDS DOCUMENTATION \n\
6928 \n\
6929 dimymax (PLINT, input) : NEEDS DOCUMENTATION \n\
6930 \n\
6931 dimxpmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
6932 \n\
6933 dimypmm (PLFLT, input) : NEEDS DOCUMENTATION \n\
6934 ";
6935 const char* _wrap_plmkstrm_texinfo = "-*- texinfo -*-\n\
6936 Creates a new stream and makes it the default \n\
6937 \n\
6938 DESCRIPTION:\n\
6939 \n\
6940 Creates a new stream and makes it the default. Differs from using\n\
6941 plsstrm, in that a free stream number is found, and returned.\n\
6942 Unfortunately, I have to start at stream 1 and work upward, since\n\
6943 stream 0 is preallocated. One of the big flaws in the PLplot API is\n\
6944 that no initial, library-opening call is required.\tSo stream 0 must\n\
6945 be preallocated, and there is no simple way of determining whether it\n\
6946 is already in use or not. \n\
6947 \n\
6948 Redacted form: plmkstrm(p_strm)\n\
6949 \n\
6950 This function is used in examples 1,20. \n\
6951 \n\
6952 \n\
6953 \n\
6954 SYNOPSIS:\n\
6955 \n\
6956 plmkstrm(p_strm)\n\
6957 \n\
6958 ARGUMENTS:\n\
6959 \n\
6960 p_strm (PLINT *, output) : Pointer to stream number of the created\n\
6961 stream. \n\
6962 ";
6963 const char* _wrap_plgpage_texinfo = "-*- texinfo -*-\n\
6964 Get page parameters \n\
6965 \n\
6966 DESCRIPTION:\n\
6967 \n\
6968 Gets the current page configuration. The length and offset values are\n\
6969 expressed in units that are specific to the current driver. For\n\
6970 instance: screen drivers will usually interpret them as number of\n\
6971 pixels, whereas printer drivers will usually use mm. \n\
6972 \n\
6973 Redacted form: plgpage(xp, yp, xleng, yleng, xoff, yoff)\n\
6974 \n\
6975 This function is used in examples 14 and 31. \n\
6976 \n\
6977 \n\
6978 \n\
6979 SYNOPSIS:\n\
6980 \n\
6981 plgpage(xp, yp, xleng, yleng, xoff, yoff)\n\
6982 \n\
6983 ARGUMENTS:\n\
6984 \n\
6985 xp (PLFLT *, output) : Pointer to number of pixels/inch (DPI), x. \n\
6986 \n\
6987 yp (PLFLT *, output) : Pointer to number of pixels/inch (DPI) in y. \n\
6988 \n\
6989 xleng (PLINT *, output) : Pointer to x page length value. \n\
6990 \n\
6991 yleng (PLINT *, output) : Pointer to y page length value. \n\
6992 \n\
6993 xoff (PLINT *, output) : Pointer to x page offset. \n\
6994 \n\
6995 yoff (PLINT *, output) : Pointer to y page offset. \n\
6996 ";
6997 const char* _wrap_pltimefmt_texinfo = "-*- texinfo -*-\n\
6998 Set format for date / time labels \n\
6999 \n\
7000 DESCRIPTION:\n\
7001 \n\
7002 Sets the format for date / time labels. To enable date / time format\n\
7003 labels see the options to plbox and plenv.\t\n\
7004 \n\
7005 Redacted form: pltimefmt(fmt)\n\
7006 \n\
7007 This function is used in example 29. \n\
7008 \n\
7009 \n\
7010 \n\
7011 SYNOPSIS:\n\
7012 \n\
7013 pltimefmt(fmt)\n\
7014 \n\
7015 ARGUMENTS:\n\
7016 \n\
7017 fmt (const char *, fmt) : This string is passed directly to the\n\
7018 system strftime. See the system documentation for a full list of\n\
7019 conversion specifications for your system. All conversion\n\
7020 specifications take the form of a \'%\' character followed by\n\
7021 further conversion specification character. All other text is\n\
7022 printed as-is. Common options include: %c: The preferred date and\n\
7023 time representation for the current locale. \n\
7024 %d: The day of the month as a decimal number. \n\
7025 %H: The hour as a decimal number using a 24-hour clock. \n\
7026 %j: The day of the year as a decimal number. \n\
7027 %m: The month as a decimal number. \n\
7028 %M: The minute as a decimal number. \n\
7029 %S: The second as a decimal number. \n\
7030 %y: The year as a decimal number without a century. \n\
7031 %Y: The year as a decimal number including a century. \n\
7032 ";
7033 const char* _wrap_plvasp_texinfo = "-*- texinfo -*-\n\
7034 Specify viewport using aspect ratio only \n\
7035 \n\
7036 DESCRIPTION:\n\
7037 \n\
7038 Sets the viewport so that the ratio of the length of the y axis to\n\
7039 that of the x axis is equal to aspect. \n\
7040 \n\
7041 Redacted form: plvasp(aspect)\n\
7042 \n\
7043 This function is used in example 13. \n\
7044 \n\
7045 \n\
7046 \n\
7047 SYNOPSIS:\n\
7048 \n\
7049 plvasp(aspect)\n\
7050 \n\
7051 ARGUMENTS:\n\
7052 \n\
7053 aspect (PLFLT, input) : Ratio of length of y axis to length of x\n\
7054 axis. \n\
7055 ";
7056 const char* _wrap_plsfnam_texinfo = "-*- texinfo -*-\n\
7057 Set output file name \n\
7058 \n\
7059 DESCRIPTION:\n\
7060 \n\
7061 Sets the current output file name, if applicable. If the file name\n\
7062 has not been specified and is required by the driver, the user will be\n\
7063 prompted for it. If using the X-windows output driver, this sets the\n\
7064 display name. This routine, if used, must be called before\n\
7065 initializing PLplot. \n\
7066 \n\
7067 Redacted form: plsfnam(fnam)\n\
7068 \n\
7069 This function is used in examples 1,20. \n\
7070 \n\
7071 \n\
7072 \n\
7073 SYNOPSIS:\n\
7074 \n\
7075 plsfnam(fnam)\n\
7076 \n\
7077 ARGUMENTS:\n\
7078 \n\
7079 fnam (const char *, input) : Pointer to file name string. \n\
7080 ";
7081 const char* _wrap_plsdiplt_texinfo = "-*- texinfo -*-\n\
7082 Set parameters that define current plot-space window \n\
7083 \n\
7084 DESCRIPTION:\n\
7085 \n\
7086 Set relative minima and maxima that define the current plot-space\n\
7087 window. If plsdiplt is not called the default values of xmin, ymin,\n\
7088 xmax, and ymax are 0., 0., 1., and 1. \n\
7089 \n\
7090 Redacted form: plsdiplt(xmin, ymin, xmax, ymax)\n\
7091 \n\
7092 This function is used in example 31. \n\
7093 \n\
7094 \n\
7095 \n\
7096 SYNOPSIS:\n\
7097 \n\
7098 plsdiplt(xmin, ymin, xmax, ymax)\n\
7099 \n\
7100 ARGUMENTS:\n\
7101 \n\
7102 xmin (PLFLT, input) : Relative minimum in x. \n\
7103 \n\
7104 ymin (PLFLT, input) : Relative minimum in y. \n\
7105 \n\
7106 xmax (PLFLT, input) : Relative maximum in x. \n\
7107 \n\
7108 ymax (PLFLT, input) : Relative maximum in y. \n\
7109 ";
7110 const char* _wrap_pllsty_texinfo = "-*- texinfo -*-\n\
7111 Select line style \n\
7112 \n\
7113 DESCRIPTION:\n\
7114 \n\
7115 This sets the line style according to one of eight predefined patterns\n\
7116 (also see plstyl). \n\
7117 \n\
7118 Redacted form: pllsty(n)\n\
7119 \n\
7120 This function is used in examples 9,12,22,25. \n\
7121 \n\
7122 \n\
7123 \n\
7124 SYNOPSIS:\n\
7125 \n\
7126 pllsty(n)\n\
7127 \n\
7128 ARGUMENTS:\n\
7129 \n\
7130 n (PLINT, input) : Integer value between 1 and 8. Line style 1 is a\n\
7131 continuous line, line style 2 is a line with short dashes and\n\
7132 gaps, line style 3 is a line with long dashes and gaps, line style\n\
7133 4 has long dashes and short gaps and so on. \n\
7134 ";
7135 const char* _wrap_plsym_texinfo = "-*- texinfo -*-\n\
7136 Plot a glyph at the specified points \n\
7137 \n\
7138 DESCRIPTION:\n\
7139 \n\
7140 Plot a glyph at the specified points. (This function is largely\n\
7141 superseded by plstring which gives access to many[!] more glyphs.) \n\
7142 \n\
7143 Redacted form: plsym(x, y, code)\n\
7144 \n\
7145 This function is used in example 7. \n\
7146 \n\
7147 \n\
7148 \n\
7149 SYNOPSIS:\n\
7150 \n\
7151 plsym(n, x, y, code)\n\
7152 \n\
7153 ARGUMENTS:\n\
7154 \n\
7155 n (PLINT, input) : Number of points in the x and y arrays. \n\
7156 \n\
7157 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7158 points. \n\
7159 \n\
7160 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7161 points. \n\
7162 \n\
7163 code (PLINT, input) : Hershey symbol code corresponding to a glyph\n\
7164 to be plotted at each of the n points. \n\
7165 ";
7166 const char* _wrap_plsdev_texinfo = "-*- texinfo -*-\n\
7167 Set the device (keyword) name \n\
7168 \n\
7169 DESCRIPTION:\n\
7170 \n\
7171 Set the device (keyword) name. \n\
7172 \n\
7173 Redacted form: plsdev(devname)\n\
7174 \n\
7175 This function is used in examples 1,14,20. \n\
7176 \n\
7177 \n\
7178 \n\
7179 SYNOPSIS:\n\
7180 \n\
7181 plsdev(devname)\n\
7182 \n\
7183 ARGUMENTS:\n\
7184 \n\
7185 devname (const char *, input) : Pointer to device (keyword) name\n\
7186 string. \n\
7187 ";
7188 const char* _wrap_plscolbg_texinfo = "-*- texinfo -*-\n\
7189 Set the background color by 8-bit RGB value \n\
7190 \n\
7191 DESCRIPTION:\n\
7192 \n\
7193 Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
7194 (see the PLplot documentation). \n\
7195 \n\
7196 Redacted form: plscolbg(r, g, b)\n\
7197 \n\
7198 This function is used in examples 15,31. \n\
7199 \n\
7200 \n\
7201 \n\
7202 SYNOPSIS:\n\
7203 \n\
7204 plscolbg(r, g, b)\n\
7205 \n\
7206 ARGUMENTS:\n\
7207 \n\
7208 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7209 degree of red in the color. \n\
7210 \n\
7211 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7212 degree of green in the color. \n\
7213 \n\
7214 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7215 degree of blue in the color. \n\
7216 ";
7217 const char* _wrap_plsdiplz_texinfo = "-*- texinfo -*-\n\
7218 Set parameters incrementally (zoom mode) that define current plot-space window \n\
7219 \n\
7220 DESCRIPTION:\n\
7221 \n\
7222 Set relative minima and maxima incrementally (zoom mode) that define\n\
7223 the current plot-space window. This function has the same effect as\n\
7224 plsdiplt if that function has not been previously called. Otherwise,\n\
7225 this function implements zoom mode using the transformation min_used =\n\
7226 old_min + old_length*min and max_used = old_min + old_length*max for\n\
7227 each axis.\tFor example, if min = 0.05 and max = 0.95 for each axis,\n\
7228 repeated calls to plsdiplz will zoom in by 10 per cent for each call. \n\
7229 \n\
7230 Redacted form: plsdiplz(xmin, ymin, xmax, ymax)\n\
7231 \n\
7232 This function is used in example 31. \n\
7233 \n\
7234 \n\
7235 \n\
7236 SYNOPSIS:\n\
7237 \n\
7238 plsdiplz(xmin, ymin, xmax, ymax)\n\
7239 \n\
7240 ARGUMENTS:\n\
7241 \n\
7242 xmin (PLFLT, input) : Relative (incremental) minimum in x. \n\
7243 \n\
7244 ymin (PLFLT, input) : Relative (incremental) minimum in y. \n\
7245 \n\
7246 xmax (PLFLT, input) : Relative (incremental) maximum in x. \n\
7247 \n\
7248 ymax (PLFLT, input) : Relative (incremental) maximum in y. \n\
7249 ";
7250 const char* _wrap_plfamadv_texinfo = "-*- texinfo -*-\n\
7251 Advance to the next family file on the next new page \n\
7252 \n\
7253 DESCRIPTION:\n\
7254 \n\
7255 Advance to the next family file on the next new page. \n\
7256 \n\
7257 Redacted form: plfamadv()\n\
7258 \n\
7259 This function is not used in any examples. \n\
7260 \n\
7261 \n\
7262 \n\
7263 SYNOPSIS:\n\
7264 \n\
7265 plfamadv()\n\
7266 ";
7267 const char* _wrap_plscmap0n_texinfo = "-*- texinfo -*-\n\
7268 Set number of colors in color map0 \n\
7269 \n\
7270 DESCRIPTION:\n\
7271 \n\
7272 Set number of colors in color map0 (see the PLplot documentation).\n\
7273 Allocate (or reallocate) color map0, and fill with default values for\n\
7274 those colors not previously allocated. The first 16 default colors are\n\
7275 given in the plcol0 documentation. For larger indices the default\n\
7276 color is red. \n\
7277 \n\
7278 The drivers are not guaranteed to support more than 16 colors. \n\
7279 \n\
7280 Redacted form: plscmap0n(ncol0)\n\
7281 \n\
7282 This function is used in examples 15,16,24. \n\
7283 \n\
7284 \n\
7285 \n\
7286 SYNOPSIS:\n\
7287 \n\
7288 plscmap0n(ncol0)\n\
7289 \n\
7290 ARGUMENTS:\n\
7291 \n\
7292 ncol0 (PLINT, input) : Number of colors that will be allocated in\n\
7293 the map0 palette. If this number is zero or less, then the value\n\
7294 from the previous call to plscmap0n is used and if there is no\n\
7295 previous call, then a default value is used. \n\
7296 ";
7297 const char* _wrap_plmeridians_texinfo = "-*- texinfo -*-\n\
7298 Plot latitude and longitude lines. \n\
7299 \n\
7300 DESCRIPTION:\n\
7301 \n\
7302 Displays latitude and longitude on the current plot. The lines are\n\
7303 plotted in the current color and line style. \n\
7304 \n\
7305 Redacted form: General: plmeridians(mapform, dlong, dlat, minlong,\n\
7306 maxlong, minlat, maxlat)\n\
7307 \t F95, Java, Perl/PDL, Python: Not implemented? \n\
7308 \n\
7309 \n\
7310 This function is used in example 19. \n\
7311 \n\
7312 \n\
7313 \n\
7314 SYNOPSIS:\n\
7315 \n\
7316 plmeridians(mapform, dlong, dlat, minlong, maxlong, minlat, maxlat)\n\
7317 \n\
7318 ARGUMENTS:\n\
7319 \n\
7320 mapform (void (*) (PLINT, PLFLT *, PLFLT *), input) : A user\n\
7321 supplied function to transform the coordinate longitudes and\n\
7322 latitudes to a plot coordinate system. By using this transform,\n\
7323 we can change from a longitude, latitude coordinate to a polar\n\
7324 stereographic project, for example. Initially, x[0]..[n-1] are\n\
7325 the longitudes and y[0]..y[n-1] are the corresponding latitudes. \n\
7326 After the call to mapform(), x[] and y[] should be replaced by\n\
7327 the corresponding plot coordinates. If no transform is desired,\n\
7328 mapform can be replaced by NULL. \n\
7329 \n\
7330 dlong (PLFLT, input) : The interval in degrees at which the\n\
7331 longitude lines are to be plotted. \n\
7332 \n\
7333 dlat (PLFLT, input) : The interval in degrees at which the latitude\n\
7334 lines are to be plotted. \n\
7335 \n\
7336 minlong (PLFLT, input) : The value of the longitude on the left\n\
7337 side of the plot. The value of minlong must be less than the\n\
7338 value of maxlong, and the quantity maxlong-minlong must be less\n\
7339 than or equal to 360. \n\
7340 \n\
7341 maxlong (PLFLT, input) : The value of the longitude on the right\n\
7342 side of the plot. \n\
7343 \n\
7344 minlat (PLFLT, input) : The minimum latitude to be plotted on the\n\
7345 background. One can always use -90.0 as the boundary outside the\n\
7346 plot window will be automatically eliminated. However, the\n\
7347 program will be faster if one can reduce the size of the\n\
7348 background plotted. \n\
7349 \n\
7350 maxlat (PLFLT, input) : The maximum latitudes to be plotted on the\n\
7351 background. One can always use 90.0 as the boundary outside the\n\
7352 plot window will be automatically eliminated. \n\
7353 ";
7354 const char* _wrap_plrgbhls_texinfo = "-*- texinfo -*-\n\
7355 Convert RGB color to HLS \n\
7356 \n\
7357 DESCRIPTION:\n\
7358 \n\
7359 Convert RGB color coordinates to HLS \n\
7360 \n\
7361 Redacted form: General: plrgbhls(r, g, b, p_h, p_l, p_s)\n\
7362 \t Perl/PDL: Not available? Implemented as plrgb/plrgb1? \n\
7363 \n\
7364 \n\
7365 This function is used in example 2. \n\
7366 \n\
7367 \n\
7368 \n\
7369 SYNOPSIS:\n\
7370 \n\
7371 plrgbhls(r, g, b, p_h, p_l, p_s)\n\
7372 \n\
7373 ARGUMENTS:\n\
7374 \n\
7375 r (PLFLT, input) : Red intensity (0.0-1.0) of the colour \n\
7376 \n\
7377 g (PLFLT, input) : Green intensity (0.0-1.0) of the colour \n\
7378 \n\
7379 b (PLFLT, input) : Blue intensity (0.0-1.0) of the colour \n\
7380 \n\
7381 p_h (PLFLT *, output) : Pointer to hue, in degrees on the colour\n\
7382 cone (0.0-360.0) \n\
7383 \n\
7384 p_l (PLFLT *, output) : Pointer to lightness, expressed as a\n\
7385 fraction of the axis of the colour cone (0.0-1.0) \n\
7386 \n\
7387 p_s (PLFLT *, output) : Pointer to saturation, expressed as a\n\
7388 fraction of the radius of the colour cone (0.0-1.0) \n\
7389 ";
7390 const char* _wrap_plstring3_texinfo = "-*- texinfo -*-\n\
7391 Plot a glyph at the specified 3D points \n\
7392 \n\
7393 DESCRIPTION:\n\
7394 \n\
7395 Plot a glyph at the specified 3D points. (Supersedes plpoin3 because\n\
7396 many[!] more glyphs are accessible with plstring3.) Set up the call to\n\
7397 this function similar to what is done for plline3. The glyph is\n\
7398 specified with a PLplot user string. Note that the user string is not\n\
7399 actually limited to one glyph so it is possible (but not normally\n\
7400 useful) to plot more than one glyph at the specified points with this\n\
7401 function. As with plmtex and plptex, the user string can contain FCI\n\
7402 escapes to determine the font, UTF-8 code to determine the glyph or\n\
7403 else PLplot escapes for Hershey or unicode text to determine the\n\
7404 glyph. \n\
7405 \n\
7406 Redacted form: plstring3(x, y, z, string)\n\
7407 \n\
7408 This function is used in example 18. \n\
7409 \n\
7410 \n\
7411 \n\
7412 SYNOPSIS:\n\
7413 \n\
7414 plstring3(n, x, y, z, string)\n\
7415 \n\
7416 ARGUMENTS:\n\
7417 \n\
7418 n (PLINT, input) : Number of points in the x, y, and z arrays. \n\
7419 \n\
7420 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7421 points. \n\
7422 \n\
7423 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7424 points. \n\
7425 \n\
7426 z (PLFLT *, input) : Pointer to an array with Z coordinates of\n\
7427 points. \n\
7428 \n\
7429 string (const char *, input) : PLplot user string corresponding to\n\
7430 the glyph to be plotted at each of the n points. \n\
7431 ";
7432 const char* _wrap_pltext_texinfo = "-*- texinfo -*-\n\
7433 Switch to text screen \n\
7434 \n\
7435 DESCRIPTION:\n\
7436 \n\
7437 Sets an interactive device to text mode, used in conjunction with\n\
7438 plgra to allow graphics and text to be interspersed. On a device\n\
7439 which supports separate text and graphics windows, this command causes\n\
7440 control to be switched to the text window.\tThis can be useful for\n\
7441 printing diagnostic messages or getting user input, which would\n\
7442 otherwise interfere with the plots. The program must switch back to\n\
7443 the graphics window before issuing plot commands, as the text (or\n\
7444 console) device will probably become quite confused otherwise. If\n\
7445 already in text mode, this command is ignored. It is also ignored on\n\
7446 devices which only support a single window or use a different method\n\
7447 for shifting focus (see also plgra). \n\
7448 \n\
7449 Redacted form: pltext()\n\
7450 \n\
7451 This function is used in example 1. \n\
7452 \n\
7453 \n\
7454 \n\
7455 SYNOPSIS:\n\
7456 \n\
7457 pltext()\n\
7458 ";
7459 const char* _wrap_plgdiplt_texinfo = "-*- texinfo -*-\n\
7460 Get parameters that define current plot-space window \n\
7461 \n\
7462 DESCRIPTION:\n\
7463 \n\
7464 Get relative minima and maxima that define current plot-space window.\n\
7465 If plsdiplt has not been called the default values pointed to by\n\
7466 p_xmin, p_ymin, p_xmax, and p_ymax will be 0., 0., 1., and 1. \n\
7467 \n\
7468 Redacted form: plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
7469 \n\
7470 This function is used in example 31. \n\
7471 \n\
7472 \n\
7473 \n\
7474 SYNOPSIS:\n\
7475 \n\
7476 plgdiplt(p_xmin, p_ymin, p_xmax, p_ymax)\n\
7477 \n\
7478 ARGUMENTS:\n\
7479 \n\
7480 p_xmin (PLFLT *, output) : Pointer to relative minimum in x. \n\
7481 \n\
7482 p_ymin (PLFLT *, output) : Pointer to relative minimum in y. \n\
7483 \n\
7484 p_xmax (PLFLT *, output) : Pointer to relative maximum in x. \n\
7485 \n\
7486 p_ymax (PLFLT *, output) : Pointer to relative maximum in y. \n\
7487 ";
7488 const char* _wrap_plglevel_texinfo = "-*- texinfo -*-\n\
7489 Get the (current) run level \n\
7490 \n\
7491 DESCRIPTION:\n\
7492 \n\
7493 Get the (current) run level. Valid settings are: 0, uninitialized \n\
7494 \t 1,\tinitialized \n\
7495 \t 2,\tviewport defined \n\
7496 \t 3,\tworld coordinates defined \n\
7497 \n\
7498 \n\
7499 Redacted form: plglevel(p_level)\n\
7500 \n\
7501 This function is used in example 31. \n\
7502 \n\
7503 \n\
7504 \n\
7505 SYNOPSIS:\n\
7506 \n\
7507 plglevel(p_level)\n\
7508 \n\
7509 ARGUMENTS:\n\
7510 \n\
7511 p_level (PLINT *, output) : Pointer to the run level. \n\
7512 ";
7513 const char* _wrap_plbin_texinfo = "-*- texinfo -*-\n\
7514 Plot a histogram from binned data \n\
7515 \n\
7516 DESCRIPTION:\n\
7517 \n\
7518 Plots a histogram consisting of nbin bins.\tThe value associated with\n\
7519 the i\'th bin is placed in x[i], and the number of points in the bin is\n\
7520 placed in y[i]. For proper operation, the values in x[i] must form a\n\
7521 strictly increasing sequence. By default, x[i] is the left-hand edge\n\
7522 of the i\'th bin. If opt=PL_BIN_CENTRED is used, the bin boundaries are\n\
7523 placed midway between the values in the x array. Also see plhist for\n\
7524 drawing histograms from unbinned data. \n\
7525 \n\
7526 Redacted form: General: plbin(x, y, opt)\n\
7527 \t Perl/PDL: plbin(nbin, x, y, opt)\n\
7528 \t Python: plbin(nbin, x, y, opt)\n\
7529 \n\
7530 \n\
7531 This function is not used in any examples. \n\
7532 \n\
7533 \n\
7534 \n\
7535 SYNOPSIS:\n\
7536 \n\
7537 plbin(nbin, x, y, opt)\n\
7538 \n\
7539 ARGUMENTS:\n\
7540 \n\
7541 nbin (PLINT, input) : Number of bins (i.e., number of values in x\n\
7542 and y arrays.) \n\
7543 \n\
7544 x (PLFLT *, input) : Pointer to array containing values associated\n\
7545 with bins. These must form a strictly increasing sequence. \n\
7546 \n\
7547 y (PLFLT *, input) : Pointer to array containing number of points\n\
7548 in bin. This is a PLFLT (instead of PLINT) array so as to allow\n\
7549 histograms of probabilities, etc. \n\
7550 \n\
7551 opt (PLINT, input) : Is a combination of several flags:\n\
7552 opt=PL_BIN_DEFAULT: The x represent the lower bin boundaries, the\n\
7553 outer bins are expanded to fill up the entire x-axis and bins of\n\
7554 zero height are simply drawn. \n\
7555 opt=PL_BIN_CENTRED|...: The bin boundaries are to be midway\n\
7556 between the x values. If the values in x are equally spaced,\n\
7557 the values are the center values of the bins. \n\
7558 opt=PL_BIN_NOEXPAND|...: The outer bins are drawn with equal\n\
7559 size as the ones inside. \n\
7560 opt=PL_BIN_NOEMPTY|...: Bins with zero height are not drawn\n\
7561 (there is a gap for such bins). \n\
7562 ";
7563 const char* _wrap_plgfont_texinfo = "-*- texinfo -*-\n\
7564 Get family, style and weight of the current font \n\
7565 \n\
7566 DESCRIPTION:\n\
7567 \n\
7568 Gets information about current font. See the PLplot documentation for\n\
7569 more information on font selection. \n\
7570 \n\
7571 Redacted form: plgfont(p_family, p_style, p_weight)\n\
7572 \n\
7573 This function is used in example 23. \n\
7574 \n\
7575 \n\
7576 \n\
7577 SYNOPSIS:\n\
7578 \n\
7579 plgfont(p_family, p_style, p_weight)\n\
7580 \n\
7581 ARGUMENTS:\n\
7582 \n\
7583 p_family (PLINT *, output) : Pointer to variable with the current\n\
7584 font family. The available values are given by the PL_FCI_*\n\
7585 constants in plplot.h. Current options are PL_FCI_SANS,\n\
7586 PL_FCI_SERIF, PL_FCI_MONO, PL_FCI_SCRIPT and PL_FCI_SYMBOL. If\n\
7587 p_family is NULL then the font family is not returned. \n\
7588 \n\
7589 p_style (PLINT *, output) : Pointer to variable with the current\n\
7590 font style. The available values are given by the PL_FCI_*\n\
7591 constants in plplot.h. Current options are PL_FCI_UPRIGHT,\n\
7592 PL_FCI_ITALIC and PL_FCI_OBLIQUE. If p_style is NULL then the\n\
7593 font style is not returned. \n\
7594 \n\
7595 p_weight (PLINT *, output) : Pointer to variable with the current\n\
7596 font weight. The available values are given by the PL_FCI_*\n\
7597 constants in plplot.h. Current options are PL_FCI_MEDIUM and\n\
7598 PL_FCI_BOLD. If p_weight is NULL then the font weight is not\n\
7599 returned. \n\
7600 ";
7601 const char* _wrap_plgzax_texinfo = "-*- texinfo -*-\n\
7602 Get z axis parameters \n\
7603 \n\
7604 DESCRIPTION:\n\
7605 \n\
7606 Identical to plgxax, except that arguments are flags for z axis. See\n\
7607 the description of plgxax for more detail. \n\
7608 \n\
7609 Redacted form: plgzax(digmax, digits)\n\
7610 \n\
7611 This function is used in example 31. \n\
7612 \n\
7613 \n\
7614 \n\
7615 SYNOPSIS:\n\
7616 \n\
7617 plgzax(digmax, digits)\n\
7618 \n\
7619 ARGUMENTS:\n\
7620 \n\
7621 digmax (PLINT *, output) : Pointer to variable with the maximum\n\
7622 number of digits for the z axis. If nonzero, the printed label\n\
7623 has been switched to a floating point representation when the\n\
7624 number of digits exceeds digmax. \n\
7625 \n\
7626 digits (PLINT *, output) : Pointer to variable with the actual\n\
7627 number of digits for the numeric labels (z axis) from the last\n\
7628 plot. \n\
7629 ";
7630 const char* _wrap_plptex3_texinfo = "-*- texinfo -*-\n\
7631 Write text inside the viewport of a 3D plot. \n\
7632 \n\
7633 DESCRIPTION:\n\
7634 \n\
7635 Writes text at a specified position and inclination and with a\n\
7636 specified shear within the viewport. Text is clipped at the viewport\n\
7637 boundaries. The reference point of a string lies along a line passing\n\
7638 through the string at half the height of a capital letter.\tThe\n\
7639 position of the reference point along this line is determined by just,\n\
7640 and the reference point is placed at world coordinates (\n\
7641 x, \n\
7642 y, \n\
7643 z) within the viewport. The inclination and shear of the string is\n\
7644 specified in terms of differences of world coordinates making it easy\n\
7645 to write text parallel to a line in a graph. \n\
7646 \n\
7647 Redacted form: plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
7648 \n\
7649 This function is used in example 28. \n\
7650 \n\
7651 \n\
7652 \n\
7653 SYNOPSIS:\n\
7654 \n\
7655 plptex3(x, y, z, dx, dy, dz, sx, sy, sz, just, text)\n\
7656 \n\
7657 ARGUMENTS:\n\
7658 \n\
7659 x (PLFLT, input) : x coordinate of reference point of string. \n\
7660 \n\
7661 y (PLFLT, input) : y coordinate of reference point of string. \n\
7662 \n\
7663 z (PLFLT, input) : z coordinate of reference point of string. \n\
7664 \n\
7665 dx (PLFLT, input) : Together with dy and \n\
7666 dz, this specifies the inclination of the string. The baseline of\n\
7667 the string is parallel to a line joining (\n\
7668 x, \n\
7669 y, \n\
7670 z) to (\n\
7671 x+\n\
7672 dx, \n\
7673 y+\n\
7674 dy, \n\
7675 z+\n\
7676 dz). \n\
7677 \n\
7678 dy (PLFLT, input) : Together with dx and \n\
7679 dz, this specifies the inclination of the string. \n\
7680 \n\
7681 dz (PLFLT, input) : Together with dx and \n\
7682 dy, this specifies the inclination of the string. \n\
7683 \n\
7684 sx (PLFLT, input) : Together with sy and \n\
7685 sz, this specifies the shear of the string. The string is sheared so\n\
7686 that the characters are vertically parallel to a line joining (\n\
7687 x, \n\
7688 y, \n\
7689 z) to (\n\
7690 x+\n\
7691 sx, \n\
7692 y+\n\
7693 sy, \n\
7694 z+\n\
7695 sz). If sx = \n\
7696 sy = \n\
7697 sz = 0.) then the text is not sheared. \n\
7698 \n\
7699 sy (PLFLT, input) : Together with sx and \n\
7700 sz, this specifies shear of the string. \n\
7701 \n\
7702 sz (PLFLT, input) : Together with sx and \n\
7703 sy, this specifies shear of the string. \n\
7704 \n\
7705 just (PLFLT, input) : Specifies the position of the string relative\n\
7706 to its reference point. If just=0., the reference point is at the\n\
7707 left and if just=1., it is at the right of the string. Other\n\
7708 values of just give intermediate justifications. \n\
7709 \n\
7710 text (const char *, input) : The string to be written out. \n\
7711 ";
7712 const char* _wrap_plaxes_texinfo = "-*- texinfo -*-\n\
7713 Draw a box with axes, etc. with arbitrary origin \n\
7714 \n\
7715 DESCRIPTION:\n\
7716 \n\
7717 Draws a box around the currently defined viewport with arbitrary\n\
7718 world-coordinate origin specified by x0 and y0 and labels it with\n\
7719 world coordinate values appropriate to the window.\tThus plaxes should\n\
7720 only be called after defining both viewport and window. The character\n\
7721 strings xopt and yopt specify how the box should be drawn as described\n\
7722 below. If ticks and/or subticks are to be drawn for a particular\n\
7723 axis, the tick intervals and number of subintervals may be specified\n\
7724 explicitly, or they may be defaulted by setting the appropriate\n\
7725 arguments to zero. \n\
7726 \n\
7727 Redacted form: General: plaxes(x0, y0, xopt, xtick, nxsub, yopt,\n\
7728 ytick, nysub)\n\
7729 \t Perl/PDL: plaxes(x0, y0, xtick, nxsub, ytick, nysub, xopt,\n\
7730 yopt)\n\
7731 \n\
7732 \n\
7733 This function is not used in any examples. \n\
7734 \n\
7735 \n\
7736 \n\
7737 SYNOPSIS:\n\
7738 \n\
7739 plaxes(x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub)\n\
7740 \n\
7741 ARGUMENTS:\n\
7742 \n\
7743 x0 (PLFLT, input) : World X coordinate of origin. \n\
7744 \n\
7745 y0 (PLFLT, input) : World Y coordinate of origin. \n\
7746 \n\
7747 xopt (const char *, input) : Pointer to character string specifying\n\
7748 options for horizontal axis. The string can include any\n\
7749 combination of the following letters (upper or lower case) in any\n\
7750 order: a: Draws axis, X-axis is horizontal line (y=0), and Y-axis\n\
7751 is vertical line (x=0). \n\
7752 b: Draws bottom (X) or left (Y) edge of frame. \n\
7753 c: Draws top (X) or right (Y) edge of frame. \n\
7754 d: Plot labels as date / time. Values are assumed to be\n\
7755 seconds since the epoch (as used by gmtime). \n\
7756 f: Always use fixed point numeric labels. \n\
7757 g: Draws a grid at the major tick interval. \n\
7758 h: Draws a grid at the minor tick interval. \n\
7759 i: Inverts tick marks, so they are drawn outwards, rather than\n\
7760 inwards. \n\
7761 l: Labels axis logarithmically. This only affects the labels,\n\
7762 not the data, and so it is necessary to compute the logarithms\n\
7763 of data points before passing them to any of the drawing\n\
7764 routines. \n\
7765 m: Writes numeric labels at major tick intervals in the\n\
7766 unconventional location (above box for X, right of box for Y). \n\
7767 n: Writes numeric labels at major tick intervals in the\n\
7768 conventional location (below box for X, left of box for Y). \n\
7769 o: Use custom labelling function to generate axis label text. \n\
7770 The custom labelling function can be defined with the\n\
7771 plslabelfunc command. \n\
7772 s: Enables subticks between major ticks, only valid if t is\n\
7773 also specified. \n\
7774 t: Draws major ticks. \n\
7775 u: Exactly like \"b\" except don\'t draw edge line. \n\
7776 w: Exactly like \"c\" except don\'t draw edge line. \n\
7777 x: Exactly like \"t\" (including the side effect of the\n\
7778 numerical labels for the major ticks) except exclude drawing\n\
7779 the major and minor tick marks. \n\
7780 \n\
7781 \n\
7782 xtick (PLFLT, input) : World coordinate interval between major\n\
7783 ticks on the x axis. If it is set to zero, PLplot automatically\n\
7784 generates a suitable tick interval. \n\
7785 \n\
7786 nxsub (PLINT, input) : Number of subintervals between major x axis\n\
7787 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
7788 generates a suitable minor tick interval. \n\
7789 \n\
7790 yopt (const char *, input) : Pointer to character string specifying\n\
7791 options for vertical axis. The string can include any combination\n\
7792 of the letters defined above for xopt, and in addition may\n\
7793 contain: v: Write numeric labels for vertical axis parallel to the\n\
7794 base of the graph, rather than parallel to the axis. \n\
7795 \n\
7796 \n\
7797 ytick (PLFLT, input) : World coordinate interval between major\n\
7798 ticks on the y axis. If it is set to zero, PLplot automatically\n\
7799 generates a suitable tick interval. \n\
7800 \n\
7801 nysub (PLINT, input) : Number of subintervals between major y axis\n\
7802 ticks for minor ticks. If it is set to zero, PLplot automatically\n\
7803 generates a suitable minor tick interval. \n\
7804 ";
7805 const char* _wrap_plgcolbg_texinfo = "-*- texinfo -*-\n\
7806 Returns the background color (cmap0[0]) by 8-bit RGB value \n\
7807 \n\
7808 DESCRIPTION:\n\
7809 \n\
7810 Returns the background color (cmap0[0]) by 8-bit RGB value. \n\
7811 \n\
7812 Redacted form: plgcolbg(r, g, b)\n\
7813 \n\
7814 This function is used in example 31. \n\
7815 \n\
7816 \n\
7817 \n\
7818 SYNOPSIS:\n\
7819 \n\
7820 plgcolbg(r, g, b)\n\
7821 \n\
7822 ARGUMENTS:\n\
7823 \n\
7824 r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7825 representing the degree of red in the color. \n\
7826 \n\
7827 g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7828 representing the degree of green in the color. \n\
7829 \n\
7830 b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7831 representing the degree of blue in the color. \n\
7832 ";
7833 const char* _wrap_plpoin3_texinfo = "-*- texinfo -*-\n\
7834 Plot a glyph at the specified 3D points \n\
7835 \n\
7836 DESCRIPTION:\n\
7837 \n\
7838 Plot a glyph at the specified 3D points. (This function is largely\n\
7839 superseded by plstring3 which gives access to many[!] more glyphs.)\n\
7840 Set up the call to this function similar to what is done for plline3.\n\
7841 code=-1 means try to just draw a point. Right now it\'s just a move\n\
7842 and a draw at the same place. Not ideal, since a sufficiently\n\
7843 intelligent output device may optimize it away, or there may be faster\n\
7844 ways of doing it. This is OK for now, though, and offers a 4X speedup\n\
7845 over drawing a Hershey font \"point\" (which is actually diamond shaped\n\
7846 and therefore takes 4 strokes to draw). If 0 < code < 32, then a\n\
7847 useful (but small subset) of Hershey symbols is plotted. If 32 <=\n\
7848 code <= 127 the corresponding printable ASCII character is plotted. \n\
7849 \n\
7850 Redacted form: plpoin3(x, y, z, code)\n\
7851 \n\
7852 This function is not used in any example. \n\
7853 \n\
7854 \n\
7855 \n\
7856 SYNOPSIS:\n\
7857 \n\
7858 plpoin3(n, x, y, z, code)\n\
7859 \n\
7860 ARGUMENTS:\n\
7861 \n\
7862 n (PLINT, input) : Number of points in the x and y arrays. \n\
7863 \n\
7864 x (PLFLT *, input) : Pointer to an array with X coordinates of\n\
7865 points. \n\
7866 \n\
7867 y (PLFLT *, input) : Pointer to an array with Y coordinates of\n\
7868 points. \n\
7869 \n\
7870 z (PLFLT *, input) : Pointer to an array with Z coordinates of\n\
7871 points. \n\
7872 \n\
7873 code (PLINT, input) : Hershey symbol code (in \"ascii-indexed\" form\n\
7874 with -1 <= code <= 127) corresponding to a glyph to be plotted at\n\
7875 each of the n points. \n\
7876 ";
7877 const char* _wrap_plpoly3_texinfo = "-*- texinfo -*-\n\
7878 Draw a polygon in 3 space \n\
7879 \n\
7880 DESCRIPTION:\n\
7881 \n\
7882 Draws a polygon in 3 space defined by n points in x, y, and z. Setup\n\
7883 like plline3, but differs from that function in that plpoly3 attempts\n\
7884 to determine if the polygon is viewable depending on the order of the\n\
7885 points within the arrays and the value of ifcc. If the back of\n\
7886 polygon is facing the viewer, then it isn\'t drawn.\tIf this isn\'t what\n\
7887 you want, then use plline3 instead. \n\
7888 \n\
7889 The points are assumed to be in a plane, and the directionality of the\n\
7890 plane is determined from the first three points. Additional points do\n\
7891 not have to lie on the plane defined by the first three, but if they\n\
7892 do not, then the determination of visibility obviously can\'t be 100%\n\
7893 accurate... So if you\'re 3 space polygons are too far from planar,\n\
7894 consider breaking them into smaller polygons. 3 points define a plane\n\
7895 :-). \n\
7896 \n\
7897 Bugs: If one of the first two segments is of zero length, or if they\n\
7898 are co-linear, the calculation of visibility has a 50/50 chance of\n\
7899 being correct. Avoid such situations :-).\tSee x18c.c for an example\n\
7900 of this problem. (Search for 20.1). \n\
7901 \n\
7902 Redacted form: plpoly3(x, y, z, code)\n\
7903 \n\
7904 This function is used in example 18. \n\
7905 \n\
7906 \n\
7907 \n\
7908 SYNOPSIS:\n\
7909 \n\
7910 plpoly3(n, x, y, z, draw, ifcc)\n\
7911 \n\
7912 ARGUMENTS:\n\
7913 \n\
7914 n (PLINT, input) : Number of points defining line. \n\
7915 \n\
7916 x (PLFLT *, input) : Pointer to array with x coordinates of points. \n\
7917 \n\
7918 y (PLFLT *, input) : Pointer to array with y coordinates of points. \n\
7919 \n\
7920 z (PLFLT *, input) : Pointer to array with z coordinates of points. \n\
7921 \n\
7922 draw (PLBOOL *, input) : Pointer to array which controls drawing\n\
7923 the segments of the polygon. If draw[i] is true, then the polygon\n\
7924 segment from index [i] to [i+1] is drawn, otherwise, not. \n\
7925 \n\
7926 ifcc (PLBOOL, input) : If ifcc is true the directionality of the\n\
7927 polygon is determined by assuming the points are laid out in a\n\
7928 counter-clockwise order. Otherwise, the directionality of the\n\
7929 polygon is determined by assuming the points are laid out in a\n\
7930 clockwise order. \n\
7931 ";
7932 const char* _wrap_plscolbga_texinfo = "-*- texinfo -*-\n\
7933 Set the background color by 8-bit RGB value and double alpha value. \n\
7934 \n\
7935 DESCRIPTION:\n\
7936 \n\
7937 Set the background color (color 0 in color map 0) by 8-bit RGB value\n\
7938 (see the PLplot documentation) and double alpha value. \n\
7939 \n\
7940 This function is used in example 31. \n\
7941 \n\
7942 \n\
7943 \n\
7944 SYNOPSIS:\n\
7945 \n\
7946 plscolbga(r, g, b, a)\n\
7947 \n\
7948 ARGUMENTS:\n\
7949 \n\
7950 r (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7951 degree of red in the color. \n\
7952 \n\
7953 g (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7954 degree of green in the color. \n\
7955 \n\
7956 b (PLINT, input) : Unsigned 8-bit integer (0-255) representing the\n\
7957 degree of blue in the color. \n\
7958 \n\
7959 a (PLFLT, input) : double value (0.0-1.0) representing the alpha\n\
7960 value of the color. \n\
7961 ";
7962 const char* _wrap_plgcolbga_texinfo = "-*- texinfo -*-\n\
7963 Returns the background color (cmap0[0]) by 8-bit RGB value and double alpha value. \n\
7964 \n\
7965 DESCRIPTION:\n\
7966 \n\
7967 Returns the background color (cmap0[0]) by 8-bit RGB value and double\n\
7968 alpha value. \n\
7969 \n\
7970 This function is used in example 31. \n\
7971 \n\
7972 \n\
7973 \n\
7974 SYNOPSIS:\n\
7975 \n\
7976 plgcolbga(r, g, b, a)\n\
7977 \n\
7978 ARGUMENTS:\n\
7979 \n\
7980 r (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7981 representing the degree of red in the color. \n\
7982 \n\
7983 g (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7984 representing the degree of green in the color. \n\
7985 \n\
7986 b (PLINT *, output) : Pointer to an unsigned 8-bit integer (0-255)\n\
7987 representing the degree of blue in the color. \n\
7988 \n\
7989 a (PLFLT *, output) : Pointer to PLFLT alpha value. \n\
7990 ";
7991 const char* _wrap_plerrx_texinfo = "-*- texinfo -*-\n\
7992 Draw x error bar \n\
7993 \n\
7994 DESCRIPTION:\n\
7995 \n\
7996 Draws a set of n horizontal error bars, the i\'th error bar extending\n\
7997 from xmin[i] to xmax[i] at y coordinate y[i]. The terminals of the\n\
7998 error bar are of length equal to the minor tick length (settable using\n\
7999 plsmin). \n\
8000 \n\
8001 Redacted form: General: plerrx(xmin, ymax, y)\n\
8002 \t Perl/PDL: plerrx(n, xmin, xmax, y)\n\
8003 \n\
8004 \n\
8005 This function is used in example 29. \n\
8006 \n\
8007 \n\
8008 \n\
8009 SYNOPSIS:\n\
8010 \n\
8011 plerrx(n, xmin, xmax, y)\n\
8012 \n\
8013 ARGUMENTS:\n\
8014 \n\
8015 n (PLINT, input) : Number of error bars to draw. \n\
8016 \n\
8017 xmin (PLFLT *, input) : Pointer to array with x coordinates of\n\
8018 left-hand endpoint of error bars. \n\
8019 \n\
8020 xmax (PLFLT *, input) : Pointer to array with x coordinates of\n\
8021 right-hand endpoint of error bars. \n\
8022 \n\
8023 y (PLFLT *, input) : Pointer to array with y coordinates of error\n\
8024 bar. \n\
8025 ";
8026 const char* _wrap_pleop_texinfo = "-*- texinfo -*-\n\
8027 Eject current page \n\
8028 \n\
8029 DESCRIPTION:\n\
8030 \n\
8031 Clears the graphics screen of an interactive device, or ejects a page\n\
8032 on a plotter. See plbop for more information. \n\
8033 \n\
8034 Redacted form: pleop()\n\
8035 \n\
8036 This function is used in example 2,14. \n\
8037 \n\
8038 \n\
8039 \n\
8040 SYNOPSIS:\n\
8041 \n\
8042 pleop()\n\
8043 ";
8044 const char* _wrap_plhlsrgb_texinfo = "-*- texinfo -*-\n\
8045 Convert HLS color to RGB \n\
8046 \n\
8047 DESCRIPTION:\n\
8048 \n\
8049 Convert HLS color coordinates to RGB. \n\
8050 \n\
8051 Redacted form: General: plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
8052 \t Perl/PDL: Not available? Implemented as plhls? \n\
8053 \n\
8054 \n\
8055 This function is used in example 2. \n\
8056 \n\
8057 \n\
8058 \n\
8059 SYNOPSIS:\n\
8060 \n\
8061 plhlsrgb(h, l, s, p_r, p_g, p_b)\n\
8062 \n\
8063 ARGUMENTS:\n\
8064 \n\
8065 h (PLFLT, input) : Hue, in degrees on the colour cone (0.0-360.0) \n\
8066 \n\
8067 l (PLFLT, input) : Lightness, expressed as a fraction of the axis\n\
8068 of the colour cone (0.0-1.0) \n\
8069 \n\
8070 s (PLFLT, input) : Saturation, expressed as a fraction of the\n\
8071 radius of the colour cone (0.0-1.0) \n\
8072 \n\
8073 p_r (PLFLT *, output) : Pointer to red intensity (0.0-1.0) of the\n\
8074 colour \n\
8075 \n\
8076 p_g (PLFLT *, output) : Pointer to green intensity (0.0-1.0) of the\n\
8077 colour \n\
8078 \n\
8079 p_b (PLFLT *, output) : Pointer to blue intensity (0.0-1.0) of the\n\
8080 colour \n\
8081 ";
8082 const char* _wrap_plerry_texinfo = "-*- texinfo -*-\n\
8083 Draw y error bar \n\
8084 \n\
8085 DESCRIPTION:\n\
8086 \n\
8087 Draws a set of n vertical error bars, the i\'th error bar extending\n\
8088 from ymin[i] to ymax[i] at x coordinate x[i]. The terminals of the\n\
8089 error bar are of length equal to the minor tick length (settable using\n\
8090 plsmin). \n\
8091 \n\
8092 Redacted form: General: plerry(x, ymin, ymax)\n\
8093 \t Perl/PDL: plerry(n, x, ymin, ymax)\n\
8094 \n\
8095 \n\
8096 This function is used in example 29. \n\
8097 \n\
8098 \n\
8099 \n\
8100 SYNOPSIS:\n\
8101 \n\
8102 plerry(n, x, ymin, ymax)\n\
8103 \n\
8104 ARGUMENTS:\n\
8105 \n\
8106 n (PLINT, input) : Number of error bars to draw. \n\
8107 \n\
8108 x (PLFLT *, input) : Pointer to array with x coordinates of error\n\
8109 bars. \n\
8110 \n\
8111 ymin (PLFLT *, input) : Pointer to array with y coordinates of\n\
8112 lower endpoint of error bars. \n\
8113 \n\
8114 ymax (PLFLT *, input) : Pointer to array with y coordinate of upper\n\
8115 endpoint of error bar. \n\
8116 ";
8117 const char* _wrap_plsfci_texinfo = "-*- texinfo -*-\n\
8118 Set FCI (font characterization integer) \n\
8119 \n\
8120 DESCRIPTION:\n\
8121 \n\
8122 Sets font characteristics to be used at the start of the next string\n\
8123 using the FCI approach. See the PLplot documentation for more\n\
8124 information. \n\
8125 \n\
8126 Redacted form: General: plsfci(fci)\n\
8127 \t Perl/PDL: Not available? \n\
8128 \n\
8129 \n\
8130 This function is used in example 23. \n\
8131 \n\
8132 \n\
8133 \n\
8134 SYNOPSIS:\n\
8135 \n\
8136 plsfci(fci)\n\
8137 \n\
8138 ARGUMENTS:\n\
8139 \n\
8140 fci (PLUNICODE, input) : PLUNICODE (unsigned 32-bit integer) value\n\
8141 of FCI. \n\
8142 ";
8143 const char* _wrap_plpsty_texinfo = "-*- texinfo -*-\n\
8144 Select area fill pattern \n\
8145 \n\
8146 DESCRIPTION:\n\
8147 \n\
8148 Select one of eight predefined area fill patterns to use (also see\n\
8149 plpat). Setting the fill style to 0 gives a solid fill. \n\
8150 \n\
8151 Redacted form: plpsty(n)\n\
8152 \n\
8153 This function is used in examples 12,13,15,16,25. \n\
8154 \n\
8155 \n\
8156 \n\
8157 SYNOPSIS:\n\
8158 \n\
8159 plpsty(n)\n\
8160 \n\
8161 ARGUMENTS:\n\
8162 \n\
8163 n (PLINT, input) : The desired pattern. Pattern 1 consists of\n\
8164 horizontal lines, pattern 2 consists of vertical lines, pattern 3\n\
8165 consists of lines at 45 degrees angle (upward), and so on. \n\
8166 ";
8167 const char* _wrap_plssym_texinfo = "-*- texinfo -*-\n\
8168 Set symbol size \n\
8169 \n\
8170 DESCRIPTION:\n\
8171 \n\
8172 This sets up the size of all subsequent symbols drawn by plpoin and\n\
8173 plsym. The actual height of a symbol is the product of the default\n\
8174 symbol size and a scaling factor as for the character height. \n\
8175 \n\
8176 Redacted form: plssym(def, scale)\n\
8177 \n\
8178 This function is used in example 29. \n\
8179 \n\
8180 \n\
8181 \n\
8182 SYNOPSIS:\n\
8183 \n\
8184 plssym(def, scale)\n\
8185 \n\
8186 ARGUMENTS:\n\
8187 \n\
8188 def (PLFLT, input) : The default height of a symbol in millimeters,\n\
8189 should be set to zero if the default height is to remain\n\
8190 unchanged. \n\
8191 \n\
8192 scale (PLFLT, input) : Scale factor to be applied to default to get\n\
8193 actual symbol height. \n\
8194 ";
8195 const char* _wrap_plstart_texinfo = "-*- texinfo -*-\n\
8196 Initialization \n\
8197 \n\
8198 DESCRIPTION:\n\
8199 \n\
8200 Alternative to plstar for initializing the plotting package. The\n\
8201 device name keyword for the desired output device must be supplied as\n\
8202 an argument. The device keywords are the same as those printed out by\n\
8203 plstar. If the requested device is not available, or if the input\n\
8204 string is empty or begins with ``?\'\', the prompted start up of plstar\n\
8205 is used. This routine also divides the output device into nx by ny\n\
8206 subpages, each of which may be used independently.\tThe subroutine\n\
8207 pladv is used to advance from one subpage to the next. \n\
8208 \n\
8209 Redacted form: General: plstart(device, nx, ny)\n\
8210 \t Perl/PDL: plstart(nx, ny, device)\n\
8211 \n\
8212 \n\
8213 This function is not used in any examples. \n\
8214 \n\
8215 \n\
8216 \n\
8217 SYNOPSIS:\n\
8218 \n\
8219 plstart(device, nx, ny)\n\
8220 \n\
8221 ARGUMENTS:\n\
8222 \n\
8223 device (const char *, input) : Device name (keyword) of the\n\
8224 required output device. If NULL or if the first character is a\n\
8225 ``?\'\', the normal (prompted) start up is used. \n\
8226 \n\
8227 nx (PLINT, input) : Number of subpages to divide output page in the\n\
8228 horizontal direction. \n\
8229 \n\
8230 ny (PLINT, input) : Number of subpages to divide output page in the\n\
8231 vertical direction. \n\
8232 ";
8233
8234 SWIG_DEFUN( testppchar, _wrap_testppchar, std::string() ) {
8235 PLINT arg1 ;
8236 PLINT *arg2 = (PLINT *) 0 ;
8237 char **arg3 = (char **) 0 ;
8238 Matrix temp1 ;
8239 octave_value_list _out;
8240 octave_value_list *_outp=&_out;
8241 octave_value _outv;
8242
8243 if (!SWIG_check_num_args("testppchar",args.length(),2,2,0)) {
8244 SWIG_fail;
8245 }
8246 {
8247 if ( _n_dims( args(0) ) > 1 )
8248 {
8249 error( "argument must be a scalar or vector" ); SWIG_fail;
8250 }
8251 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
8252 arg2 = new PLINT[Alen];
8253 temp1 = args(0).matrix_value();
8254 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
8255 }
8256 {
8257 charMatrix temp_matrix;
8258 Cell temp_cell;
8259 char *tmp_cstring;
8260 std::string str;
8261 size_t max_length = 0, non_blank_length;
8262 int i, ifcell;
8263 if ( _n_dims( args(1) ) > 2 )
8264 {
8265 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
8266 }
8267 if ( !args(1).is_empty() )
8268 {
8269 if ( _dim( args(1), 0 ) != Alen )
8270 {
8271 error( "first dimension must be same length as previous vector" ); SWIG_fail;
8272 }
8273 arg3 = new char*[Alen];
8274 ifcell = args(1).is_cell();
8275 if ( ifcell )
8276 {
8277 temp_cell = args(1).cell_value();
8278 }
8279 else
8280 {
8281 temp_matrix = args(1).char_matrix_value();
8282 // Allow one extra space for null termination.
8283 max_length = _dim( args(1), 1 ) + 1;
8284 }
8285
8286 for ( i = 0; i < Alen; i++ )
8287 {
8288 // Must copy string to "permanent" location because the string
8289 // location corresponding to tmp_cstring gets
8290 // overwritten for each iteration of loop.
8291 if ( ifcell )
8292 {
8293 if ( temp_cell.elem( i ).is_string() )
8294 {
8295 str = temp_cell.elem( i ).string_value();
8296 // leave room for null termination.
8297 max_length = str.size() + 1;
8298 tmp_cstring = (char *) str.c_str();
8299 }
8300 else
8301 {
8302 // Use null string if user attempts to pass a cell array
8303 // with a non-string element (likely an empty element
8304 // since that should be allowed by the PLplot interface
8305 // if that element is going to be unused).
8306 // leave room for null termination.
8307 max_length = 1;
8308 tmp_cstring = (char *) "";
8309 }
8310 }
8311 else
8312 {
8313 tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
8314 }
8315 arg3[i] = new char[max_length];
8316 strncpy( arg3[i], tmp_cstring, max_length - 1 );
8317 arg3[i][max_length - 1] = '\0';
8318 // All the trailing blank crapola should not be needed for
8319 // string cell arrays.
8320 if ( !ifcell )
8321 {
8322 // remove trailing-blank padding that is used by the
8323 // charMatrix class to insure all strings in a given
8324 // charMatrix instance have the same length.
8325 // This transformation also removes legitimate trailing
8326 // blanks but there is nothing we can do about that
8327 // for the charMatrix class.
8328
8329 // Look for trailing nulls first (just in case, although that
8330 // shouldn't happen if charMatrix implemented as documented)
8331 // before looking for trailing blanks.
8332 non_blank_length = max_length - 2;
8333 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == '\0' )
8334 {
8335 non_blank_length--;
8336 }
8337 while ( non_blank_length >= 0 && arg3[i][non_blank_length] == ' ' )
8338 {
8339 non_blank_length--;
8340 }
8341 arg3[i][non_blank_length + 1] = '\0';
8342 }
8343 }
8344 }
8345 else
8346 {
8347 arg3 = NULL;
8348 }
8349 }
8350 testppchar(arg1,(int const *)arg2,(char const **)arg3);
8351 _outv = octave_value();
8352 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8353 {
8354 delete [] arg2;
8355 }
8356 {
8357 int i;
8358 if ( arg3 != NULL )
8359 {
8360 for ( i = 0; i < Alen; i++ )
8361 {
8362 delete[] arg3[i];
8363 }
8364 delete[] arg3;
8365 }
8366 }
8367 fail:
8368 return _out;
8369 }
8370
8371
8372 SWIG_DEFUN( plGetCursor, _wrap_plGetCursor, std::string() ) {
8373 int *arg1 = (int *) 0 ;
8374 int *arg2 = (int *) 0 ;
8375 int *arg3 = (int *) 0 ;
8376 char *arg4 = (char *) 0 ;
8377 int *arg5 = (int *) 0 ;
8378 int *arg6 = (int *) 0 ;
8379 PLFLT *arg7 = (PLFLT *) 0 ;
8380 PLFLT *arg8 = (PLFLT *) 0 ;
8381 PLFLT *arg9 = (PLFLT *) 0 ;
8382 PLFLT *arg10 = (PLFLT *) 0 ;
8383 int *arg11 = (int *) 0 ;
8384 int temp1 ;
8385 int res1 = SWIG_TMPOBJ ;
8386 int temp2 ;
8387 int res2 = SWIG_TMPOBJ ;
8388 int temp3 ;
8389 int res3 = SWIG_TMPOBJ ;
8390 octave_value_list retval4 ;
8391 int temp5 ;
8392 int res5 = SWIG_TMPOBJ ;
8393 int temp6 ;
8394 int res6 = SWIG_TMPOBJ ;
8395 PLFLT temp7 ;
8396 int res7 = SWIG_TMPOBJ ;
8397 PLFLT temp8 ;
8398 int res8 = SWIG_TMPOBJ ;
8399 PLFLT temp9 ;
8400 int res9 = SWIG_TMPOBJ ;
8401 PLFLT temp10 ;
8402 int res10 = SWIG_TMPOBJ ;
8403 int temp11 ;
8404 int res11 = SWIG_TMPOBJ ;
8405 octave_value_list _out;
8406 octave_value_list *_outp=&_out;
8407 octave_value _outv;
8408 int result;
8409
8410 arg1 = &temp1;
8411 arg2 = &temp2;
8412 arg3 = &temp3;
8413 {
8414 // Check if version >= 3.4.0
8415 # if OCTAVE_API_VERSION_NUMBER < 45
8416 retval4( 0 ) = octave_value( charMatrix( 80, 1 ), true );
8417 # else
8418 retval4( 0 ) = octave_value( charMatrix( 80, 1 ) );
8419 # endif
8420 arg4 = (char *) retval4( 0 ).char_matrix_value().data();
8421 }
8422 arg5 = &temp5;
8423 arg6 = &temp6;
8424 arg7 = &temp7;
8425 arg8 = &temp8;
8426 arg9 = &temp9;
8427 arg10 = &temp10;
8428 arg11 = &temp11;
8429 if (!SWIG_check_num_args("plGetCursor",args.length(),0,0,0)) {
8430 SWIG_fail;
8431 }
8432 result = (int)my_plGetCursor(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
8433 _outv = SWIG_From_int((int)(result));
8434 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8435 if (SWIG_IsTmpObj(res1)) {
8436 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
8437 } else {
8438 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8439 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8440 }
8441 if (SWIG_IsTmpObj(res2)) {
8442 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
8443 } else {
8444 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8445 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8446 }
8447 if (SWIG_IsTmpObj(res3)) {
8448 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
8449 } else {
8450 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8451 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8452 }
8453 {
8454 _outp = SWIG_Octave_AppendOutput( _outp, retval4( 0 ) );
8455 }
8456 if (SWIG_IsTmpObj(res5)) {
8457 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
8458 } else {
8459 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8460 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
8461 }
8462 if (SWIG_IsTmpObj(res6)) {
8463 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
8464 } else {
8465 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8466 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
8467 }
8468 if (SWIG_IsTmpObj(res7)) {
8469 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
8470 } else {
8471 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8472 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
8473 }
8474 if (SWIG_IsTmpObj(res8)) {
8475 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg8)));
8476 } else {
8477 int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8478 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
8479 }
8480 if (SWIG_IsTmpObj(res9)) {
8481 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg9)));
8482 } else {
8483 int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8484 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
8485 }
8486 if (SWIG_IsTmpObj(res10)) {
8487 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg10)));
8488 } else {
8489 int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8490 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags));
8491 }
8492 if (SWIG_IsTmpObj(res11)) {
8493 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg11)));
8494 } else {
8495 int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8496 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_int, new_flags));
8497 }
8498 fail:
8499 return _out;
8500 }
8501
8502
8503 SWIG_DEFUN( plTranslateCursor, _wrap_plTranslateCursor, std::string() ) {
8504 PLFLT *arg1 = (PLFLT *) 0 ;
8505 PLFLT *arg2 = (PLFLT *) 0 ;
8506 PLFLT arg3 ;
8507 PLFLT arg4 ;
8508 PLFLT temp1 ;
8509 int res1 = SWIG_TMPOBJ ;
8510 PLFLT temp2 ;
8511 int res2 = SWIG_TMPOBJ ;
8512 double val3 ;
8513 int ecode3 = 0 ;
8514 double val4 ;
8515 int ecode4 = 0 ;
8516 octave_value_list _out;
8517 octave_value_list *_outp=&_out;
8518 octave_value _outv;
8519 int result;
8520
8521 arg1 = &temp1;
8522 arg2 = &temp2;
8523 if (!SWIG_check_num_args("plTranslateCursor",args.length(),2,2,0)) {
8524 SWIG_fail;
8525 }
8526 ecode3 = SWIG_AsVal_double(args(0), &val3);
8527 if (!SWIG_IsOK(ecode3)) {
8528 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plTranslateCursor" "', argument " "3"" of type '" "PLFLT""'");
8529 }
8530 arg3 = (PLFLT)(val3);
8531 ecode4 = SWIG_AsVal_double(args(1), &val4);
8532 if (!SWIG_IsOK(ecode4)) {
8533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plTranslateCursor" "', argument " "4"" of type '" "PLFLT""'");
8534 }
8535 arg4 = (PLFLT)(val4);
8536 result = (int)my_plTranslateCursor(arg1,arg2,arg3,arg4);
8537 _outv = SWIG_From_int((int)(result));
8538 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8539 if (SWIG_IsTmpObj(res1)) {
8540 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
8541 } else {
8542 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8543 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
8544 }
8545 if (SWIG_IsTmpObj(res2)) {
8546 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
8547 } else {
8548 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8549 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
8550 }
8551 fail:
8552 return _out;
8553 }
8554
8555
8556 SWIG_DEFUN( plstripc, _wrap_plstripc, std::string() ) {
8557 PLINT *arg1 = (PLINT *) 0 ;
8558 char *arg2 = (char *) 0 ;
8559 char *arg3 = (char *) 0 ;
8560 PLFLT arg4 ;
8561 PLFLT arg5 ;
8562 PLFLT arg6 ;
8563 PLFLT arg7 ;
8564 PLFLT arg8 ;
8565 PLFLT arg9 ;
8566 PLFLT arg10 ;
8567 PLBOOL arg11 ;
8568 PLBOOL arg12 ;
8569 PLINT arg13 ;
8570 PLINT arg14 ;
8571 PLINT *arg15 = (PLINT *) 0 ;
8572 PLINT *arg16 = (PLINT *) 0 ;
8573 char *arg17 = (char *) 0 ;
8574 char *arg18 = (char *) 0 ;
8575 char *arg19 = (char *) 0 ;
8576 char *arg20 = (char *) 0 ;
8577 char *arg21 = (char *) 0 ;
8578 char *arg22 = (char *) 0 ;
8579 char *arg23 = (char *) 0 ;
8580 PLINT temp1 ;
8581 int res1 = SWIG_TMPOBJ ;
8582 int res2 ;
8583 char *buf2 = 0 ;
8584 int alloc2 = 0 ;
8585 int res3 ;
8586 char *buf3 = 0 ;
8587 int alloc3 = 0 ;
8588 double val4 ;
8589 int ecode4 = 0 ;
8590 double val5 ;
8591 int ecode5 = 0 ;
8592 double val6 ;
8593 int ecode6 = 0 ;
8594 double val7 ;
8595 int ecode7 = 0 ;
8596 double val8 ;
8597 int ecode8 = 0 ;
8598 double val9 ;
8599 int ecode9 = 0 ;
8600 double val10 ;
8601 int ecode10 = 0 ;
8602 int val11 ;
8603 int ecode11 = 0 ;
8604 int val12 ;
8605 int ecode12 = 0 ;
8606 int val13 ;
8607 int ecode13 = 0 ;
8608 int val14 ;
8609 int ecode14 = 0 ;
8610 Matrix temp15 ;
8611 Matrix temp16 ;
8612 int res17 ;
8613 char *buf17 = 0 ;
8614 int alloc17 = 0 ;
8615 int res18 ;
8616 char *buf18 = 0 ;
8617 int alloc18 = 0 ;
8618 int res19 ;
8619 char *buf19 = 0 ;
8620 int alloc19 = 0 ;
8621 int res20 ;
8622 char *buf20 = 0 ;
8623 int alloc20 = 0 ;
8624 int res21 ;
8625 char *buf21 = 0 ;
8626 int alloc21 = 0 ;
8627 int res22 ;
8628 char *buf22 = 0 ;
8629 int alloc22 = 0 ;
8630 int res23 ;
8631 char *buf23 = 0 ;
8632 int alloc23 = 0 ;
8633 octave_value_list _out;
8634 octave_value_list *_outp=&_out;
8635 octave_value _outv;
8636
8637 arg1 = &temp1;
8638 if (!SWIG_check_num_args("plstripc",args.length(),22,22,0)) {
8639 SWIG_fail;
8640 }
8641 res2 = SWIG_AsCharPtrAndSize(args(0), &buf2, NULL, &alloc2);
8642 if (!SWIG_IsOK(res2)) {
8643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstripc" "', argument " "2"" of type '" "char const *""'");
8644 }
8645 arg2 = (char *)(buf2);
8646 res3 = SWIG_AsCharPtrAndSize(args(1), &buf3, NULL, &alloc3);
8647 if (!SWIG_IsOK(res3)) {
8648 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plstripc" "', argument " "3"" of type '" "char const *""'");
8649 }
8650 arg3 = (char *)(buf3);
8651 ecode4 = SWIG_AsVal_double(args(2), &val4);
8652 if (!SWIG_IsOK(ecode4)) {
8653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripc" "', argument " "4"" of type '" "PLFLT""'");
8654 }
8655 arg4 = (PLFLT)(val4);
8656 ecode5 = SWIG_AsVal_double(args(3), &val5);
8657 if (!SWIG_IsOK(ecode5)) {
8658 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plstripc" "', argument " "5"" of type '" "PLFLT""'");
8659 }
8660 arg5 = (PLFLT)(val5);
8661 ecode6 = SWIG_AsVal_double(args(4), &val6);
8662 if (!SWIG_IsOK(ecode6)) {
8663 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plstripc" "', argument " "6"" of type '" "PLFLT""'");
8664 }
8665 arg6 = (PLFLT)(val6);
8666 ecode7 = SWIG_AsVal_double(args(5), &val7);
8667 if (!SWIG_IsOK(ecode7)) {
8668 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plstripc" "', argument " "7"" of type '" "PLFLT""'");
8669 }
8670 arg7 = (PLFLT)(val7);
8671 ecode8 = SWIG_AsVal_double(args(6), &val8);
8672 if (!SWIG_IsOK(ecode8)) {
8673 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plstripc" "', argument " "8"" of type '" "PLFLT""'");
8674 }
8675 arg8 = (PLFLT)(val8);
8676 ecode9 = SWIG_AsVal_double(args(7), &val9);
8677 if (!SWIG_IsOK(ecode9)) {
8678 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plstripc" "', argument " "9"" of type '" "PLFLT""'");
8679 }
8680 arg9 = (PLFLT)(val9);
8681 ecode10 = SWIG_AsVal_double(args(8), &val10);
8682 if (!SWIG_IsOK(ecode10)) {
8683 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plstripc" "', argument " "10"" of type '" "PLFLT""'");
8684 }
8685 arg10 = (PLFLT)(val10);
8686 ecode11 = SWIG_AsVal_int(args(9), &val11);
8687 if (!SWIG_IsOK(ecode11)) {
8688 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plstripc" "', argument " "11"" of type '" "PLBOOL""'");
8689 }
8690 arg11 = (PLBOOL)(val11);
8691 ecode12 = SWIG_AsVal_int(args(10), &val12);
8692 if (!SWIG_IsOK(ecode12)) {
8693 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plstripc" "', argument " "12"" of type '" "PLBOOL""'");
8694 }
8695 arg12 = (PLBOOL)(val12);
8696 ecode13 = SWIG_AsVal_int(args(11), &val13);
8697 if (!SWIG_IsOK(ecode13)) {
8698 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plstripc" "', argument " "13"" of type '" "PLINT""'");
8699 }
8700 arg13 = (PLINT)(val13);
8701 ecode14 = SWIG_AsVal_int(args(12), &val14);
8702 if (!SWIG_IsOK(ecode14)) {
8703 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plstripc" "', argument " "14"" of type '" "PLINT""'");
8704 }
8705 arg14 = (PLINT)(val14);
8706 {
8707 if ( _n_dims( args(13) ) > 1 )
8708 {
8709 error( "argument must be a scalar or vector" ); SWIG_fail;
8710 }
8711 Alen = (PLINT) ( _dim( args(13), 0 ) );
8712 temp15 = args(13).matrix_value();
8713 arg15 = new PLINT[Alen];
8714 _cvt_double_to( arg15, &temp15( 0, 0 ), Alen );
8715 }
8716 {
8717 if ( _n_dims( args(14) ) > 1 )
8718 {
8719 error( "argument must be a scalar or vector" ); SWIG_fail;
8720 }
8721 if ( _dim( args(14), 0 ) != Alen )
8722 {
8723 error( "argument vectors must be same length" ); SWIG_fail;
8724 }
8725 temp16 = args(14).matrix_value();
8726 arg16 = new PLINT[Alen];
8727 _cvt_double_to( arg16, &temp16( 0, 0 ), Alen );
8728 }
8729 res17 = SWIG_AsCharPtrAndSize(args(15), &buf17, NULL, &alloc17);
8730 if (!SWIG_IsOK(res17)) {
8731 SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "plstripc" "', argument " "17"" of type '" "char const *""'");
8732 }
8733 arg17 = (char *)(buf17);
8734 res18 = SWIG_AsCharPtrAndSize(args(16), &buf18, NULL, &alloc18);
8735 if (!SWIG_IsOK(res18)) {
8736 SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "plstripc" "', argument " "18"" of type '" "char const *""'");
8737 }
8738 arg18 = (char *)(buf18);
8739 res19 = SWIG_AsCharPtrAndSize(args(17), &buf19, NULL, &alloc19);
8740 if (!SWIG_IsOK(res19)) {
8741 SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "plstripc" "', argument " "19"" of type '" "char const *""'");
8742 }
8743 arg19 = (char *)(buf19);
8744 res20 = SWIG_AsCharPtrAndSize(args(18), &buf20, NULL, &alloc20);
8745 if (!SWIG_IsOK(res20)) {
8746 SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "plstripc" "', argument " "20"" of type '" "char const *""'");
8747 }
8748 arg20 = (char *)(buf20);
8749 res21 = SWIG_AsCharPtrAndSize(args(19), &buf21, NULL, &alloc21);
8750 if (!SWIG_IsOK(res21)) {
8751 SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "plstripc" "', argument " "21"" of type '" "char const *""'");
8752 }
8753 arg21 = (char *)(buf21);
8754 res22 = SWIG_AsCharPtrAndSize(args(20), &buf22, NULL, &alloc22);
8755 if (!SWIG_IsOK(res22)) {
8756 SWIG_exception_fail(SWIG_ArgError(res22), "in method '" "plstripc" "', argument " "22"" of type '" "char const *""'");
8757 }
8758 arg22 = (char *)(buf22);
8759 res23 = SWIG_AsCharPtrAndSize(args(21), &buf23, NULL, &alloc23);
8760 if (!SWIG_IsOK(res23)) {
8761 SWIG_exception_fail(SWIG_ArgError(res23), "in method '" "plstripc" "', argument " "23"" of type '" "char const *""'");
8762 }
8763 arg23 = (char *)(buf23);
8764 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);
8765 _outv = octave_value();
8766 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8767 if (SWIG_IsTmpObj(res1)) {
8768 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
8769 } else {
8770 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8771 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
8772 }
8773 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
8774 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
8775 {
8776 delete [] arg15;
8777 }
8778 {
8779 delete [] arg16;
8780 }
8781 if (alloc17 == SWIG_NEWOBJ) delete[] buf17;
8782 if (alloc18 == SWIG_NEWOBJ) delete[] buf18;
8783 if (alloc19 == SWIG_NEWOBJ) delete[] buf19;
8784 if (alloc20 == SWIG_NEWOBJ) delete[] buf20;
8785 if (alloc21 == SWIG_NEWOBJ) delete[] buf21;
8786 if (alloc22 == SWIG_NEWOBJ) delete[] buf22;
8787 if (alloc23 == SWIG_NEWOBJ) delete[] buf23;
8788 fail:
8789 return _out;
8790 }
8791
8792
8793 SWIG_DEFUN( plcont, _wrap_plcont, std::string() ) {
8794 PLFLT *arg1 = (PLFLT *) 0 ;
8795 PLINT arg2 ;
8796 PLINT arg3 ;
8797 PLINT arg4 ;
8798 PLINT arg5 ;
8799 PLINT arg6 ;
8800 PLINT arg7 ;
8801 PLFLT *arg8 = (PLFLT *) 0 ;
8802 PLINT arg9 ;
8803 PLFLT *arg10 = (PLFLT *) 0 ;
8804 Matrix temp1 ;
8805 int val4 ;
8806 int ecode4 = 0 ;
8807 int val5 ;
8808 int ecode5 = 0 ;
8809 int val6 ;
8810 int ecode6 = 0 ;
8811 int val7 ;
8812 int ecode7 = 0 ;
8813 Matrix temp8 ;
8814 Matrix temp10 ;
8815 octave_value_list _out;
8816 octave_value_list *_outp=&_out;
8817 octave_value _outv;
8818
8819 if (!SWIG_check_num_args("plcont",args.length(),7,7,0)) {
8820 SWIG_fail;
8821 }
8822 {
8823 if ( _n_dims( args(0) ) > 2 )
8824 {
8825 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
8826 }
8827 temp1 = args(0).matrix_value();
8828 arg1 = &temp1( 0, 0 );
8829 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
8830 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
8831 }
8832 ecode4 = SWIG_AsVal_int(args(1), &val4);
8833 if (!SWIG_IsOK(ecode4)) {
8834 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont" "', argument " "4"" of type '" "PLINT""'");
8835 }
8836 arg4 = (PLINT)(val4);
8837 ecode5 = SWIG_AsVal_int(args(2), &val5);
8838 if (!SWIG_IsOK(ecode5)) {
8839 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont" "', argument " "5"" of type '" "PLINT""'");
8840 }
8841 arg5 = (PLINT)(val5);
8842 ecode6 = SWIG_AsVal_int(args(3), &val6);
8843 if (!SWIG_IsOK(ecode6)) {
8844 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont" "', argument " "6"" of type '" "PLINT""'");
8845 }
8846 arg6 = (PLINT)(val6);
8847 ecode7 = SWIG_AsVal_int(args(4), &val7);
8848 if (!SWIG_IsOK(ecode7)) {
8849 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont" "', argument " "7"" of type '" "PLINT""'");
8850 }
8851 arg7 = (PLINT)(val7);
8852 {
8853 if ( _n_dims( args(5) ) > 1 )
8854 {
8855 error( "argument must be a scalar or vector" ); SWIG_fail;
8856 }
8857 temp8 = args(5).matrix_value();
8858 arg8 = &temp8( 0, 0 );
8859 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
8860 }
8861 {
8862 if ( _n_dims( args(6) ) > 1 )
8863 {
8864 error( "argument must be a scalar or vector" ); SWIG_fail;
8865 }
8866 if ( _dim( args(6), 0 ) != 6 )
8867 {
8868 error( "argument vectors must have length of 6" ); SWIG_fail;
8869 }
8870 temp10 = args(6).matrix_value();
8871 arg10 = &temp10( 0, 0 );
8872 }
8873 my_plcont((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10);
8874 _outv = octave_value();
8875 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8876 {
8877
8878 }
8879 {
8880
8881 }
8882 {
8883
8884 }
8885 fail:
8886 return _out;
8887 }
8888
8889
8890 SWIG_DEFUN( plcont0, _wrap_plcont0, std::string() ) {
8891 PLFLT *arg1 = (PLFLT *) 0 ;
8892 PLINT arg2 ;
8893 PLINT arg3 ;
8894 PLINT arg4 ;
8895 PLINT arg5 ;
8896 PLINT arg6 ;
8897 PLINT arg7 ;
8898 PLFLT *arg8 = (PLFLT *) 0 ;
8899 PLINT arg9 ;
8900 Matrix temp1 ;
8901 int val4 ;
8902 int ecode4 = 0 ;
8903 int val5 ;
8904 int ecode5 = 0 ;
8905 int val6 ;
8906 int ecode6 = 0 ;
8907 int val7 ;
8908 int ecode7 = 0 ;
8909 Matrix temp8 ;
8910 octave_value_list _out;
8911 octave_value_list *_outp=&_out;
8912 octave_value _outv;
8913
8914 if (!SWIG_check_num_args("plcont0",args.length(),6,6,0)) {
8915 SWIG_fail;
8916 }
8917 {
8918 if ( _n_dims( args(0) ) > 2 )
8919 {
8920 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
8921 }
8922 temp1 = args(0).matrix_value();
8923 arg1 = &temp1( 0, 0 );
8924 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
8925 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
8926 }
8927 ecode4 = SWIG_AsVal_int(args(1), &val4);
8928 if (!SWIG_IsOK(ecode4)) {
8929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont0" "', argument " "4"" of type '" "PLINT""'");
8930 }
8931 arg4 = (PLINT)(val4);
8932 ecode5 = SWIG_AsVal_int(args(2), &val5);
8933 if (!SWIG_IsOK(ecode5)) {
8934 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont0" "', argument " "5"" of type '" "PLINT""'");
8935 }
8936 arg5 = (PLINT)(val5);
8937 ecode6 = SWIG_AsVal_int(args(3), &val6);
8938 if (!SWIG_IsOK(ecode6)) {
8939 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont0" "', argument " "6"" of type '" "PLINT""'");
8940 }
8941 arg6 = (PLINT)(val6);
8942 ecode7 = SWIG_AsVal_int(args(4), &val7);
8943 if (!SWIG_IsOK(ecode7)) {
8944 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont0" "', argument " "7"" of type '" "PLINT""'");
8945 }
8946 arg7 = (PLINT)(val7);
8947 {
8948 if ( _n_dims( args(5) ) > 1 )
8949 {
8950 error( "argument must be a scalar or vector" ); SWIG_fail;
8951 }
8952 temp8 = args(5).matrix_value();
8953 arg8 = &temp8( 0, 0 );
8954 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
8955 }
8956 my_plcont0((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9);
8957 _outv = octave_value();
8958 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
8959 {
8960
8961 }
8962 {
8963
8964 }
8965 fail:
8966 return _out;
8967 }
8968
8969
8970 SWIG_DEFUN( plcont1, _wrap_plcont1, std::string() ) {
8971 PLFLT *arg1 = (PLFLT *) 0 ;
8972 PLINT arg2 ;
8973 PLINT arg3 ;
8974 PLINT arg4 ;
8975 PLINT arg5 ;
8976 PLINT arg6 ;
8977 PLINT arg7 ;
8978 PLFLT *arg8 = (PLFLT *) 0 ;
8979 PLINT arg9 ;
8980 PLFLT *arg10 = (PLFLT *) 0 ;
8981 PLFLT *arg11 = (PLFLT *) 0 ;
8982 Matrix temp1 ;
8983 int val4 ;
8984 int ecode4 = 0 ;
8985 int val5 ;
8986 int ecode5 = 0 ;
8987 int val6 ;
8988 int ecode6 = 0 ;
8989 int val7 ;
8990 int ecode7 = 0 ;
8991 Matrix temp8 ;
8992 Matrix temp10 ;
8993 Matrix temp11 ;
8994 octave_value_list _out;
8995 octave_value_list *_outp=&_out;
8996 octave_value _outv;
8997
8998 if (!SWIG_check_num_args("plcont1",args.length(),8,8,0)) {
8999 SWIG_fail;
9000 }
9001 {
9002 if ( _n_dims( args(0) ) > 2 )
9003 {
9004 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9005 }
9006 temp1 = args(0).matrix_value();
9007 arg1 = &temp1( 0, 0 );
9008 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
9009 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
9010 }
9011 ecode4 = SWIG_AsVal_int(args(1), &val4);
9012 if (!SWIG_IsOK(ecode4)) {
9013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont1" "', argument " "4"" of type '" "PLINT""'");
9014 }
9015 arg4 = (PLINT)(val4);
9016 ecode5 = SWIG_AsVal_int(args(2), &val5);
9017 if (!SWIG_IsOK(ecode5)) {
9018 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont1" "', argument " "5"" of type '" "PLINT""'");
9019 }
9020 arg5 = (PLINT)(val5);
9021 ecode6 = SWIG_AsVal_int(args(3), &val6);
9022 if (!SWIG_IsOK(ecode6)) {
9023 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont1" "', argument " "6"" of type '" "PLINT""'");
9024 }
9025 arg6 = (PLINT)(val6);
9026 ecode7 = SWIG_AsVal_int(args(4), &val7);
9027 if (!SWIG_IsOK(ecode7)) {
9028 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont1" "', argument " "7"" of type '" "PLINT""'");
9029 }
9030 arg7 = (PLINT)(val7);
9031 {
9032 if ( _n_dims( args(5) ) > 1 )
9033 {
9034 error( "argument must be a scalar or vector" ); SWIG_fail;
9035 }
9036 temp8 = args(5).matrix_value();
9037 arg8 = &temp8( 0, 0 );
9038 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
9039 }
9040 {
9041 if ( _n_dims( args(6) ) > 1 )
9042 {
9043 error( "argument must be a scalar or vector" ); SWIG_fail;
9044 }
9045 if ( _dim( args(6), 0 ) != Xlen )
9046 {
9047 error( "argument vectors must be same length" ); SWIG_fail;
9048 }
9049 temp10 = args(6).matrix_value();
9050 arg10 = &temp10( 0, 0 );
9051 }
9052 {
9053 if ( _n_dims( args(7) ) > 1 )
9054 {
9055 error( "argument must be a scalar or vector" ); SWIG_fail;
9056 }
9057 if ( _dim( args(7), 0 ) != Ylen )
9058 {
9059 error( "argument vectors must be same length" ); SWIG_fail;
9060 }
9061 temp11 = args(7).matrix_value();
9062 arg11 = &temp11( 0, 0 );
9063 }
9064 my_plcont1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
9065 _outv = octave_value();
9066 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9067 {
9068
9069 }
9070 {
9071
9072 }
9073 {
9074
9075 }
9076 {
9077
9078 }
9079 fail:
9080 return _out;
9081 }
9082
9083
9084 SWIG_DEFUN( plcont2, _wrap_plcont2, std::string() ) {
9085 PLFLT *arg1 = (PLFLT *) 0 ;
9086 PLINT arg2 ;
9087 PLINT arg3 ;
9088 PLINT arg4 ;
9089 PLINT arg5 ;
9090 PLINT arg6 ;
9091 PLINT arg7 ;
9092 PLFLT *arg8 = (PLFLT *) 0 ;
9093 PLINT arg9 ;
9094 PLFLT *arg10 = (PLFLT *) 0 ;
9095 PLFLT *arg11 = (PLFLT *) 0 ;
9096 Matrix temp1 ;
9097 int val4 ;
9098 int ecode4 = 0 ;
9099 int val5 ;
9100 int ecode5 = 0 ;
9101 int val6 ;
9102 int ecode6 = 0 ;
9103 int val7 ;
9104 int ecode7 = 0 ;
9105 Matrix temp8 ;
9106 Matrix temp10 ;
9107 Matrix temp11 ;
9108 octave_value_list _out;
9109 octave_value_list *_outp=&_out;
9110 octave_value _outv;
9111
9112 if (!SWIG_check_num_args("plcont2",args.length(),8,8,0)) {
9113 SWIG_fail;
9114 }
9115 {
9116 if ( _n_dims( args(0) ) > 2 )
9117 {
9118 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9119 }
9120 temp1 = args(0).matrix_value();
9121 arg1 = &temp1( 0, 0 );
9122 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
9123 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
9124 }
9125 ecode4 = SWIG_AsVal_int(args(1), &val4);
9126 if (!SWIG_IsOK(ecode4)) {
9127 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2" "', argument " "4"" of type '" "PLINT""'");
9128 }
9129 arg4 = (PLINT)(val4);
9130 ecode5 = SWIG_AsVal_int(args(2), &val5);
9131 if (!SWIG_IsOK(ecode5)) {
9132 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2" "', argument " "5"" of type '" "PLINT""'");
9133 }
9134 arg5 = (PLINT)(val5);
9135 ecode6 = SWIG_AsVal_int(args(3), &val6);
9136 if (!SWIG_IsOK(ecode6)) {
9137 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2" "', argument " "6"" of type '" "PLINT""'");
9138 }
9139 arg6 = (PLINT)(val6);
9140 ecode7 = SWIG_AsVal_int(args(4), &val7);
9141 if (!SWIG_IsOK(ecode7)) {
9142 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2" "', argument " "7"" of type '" "PLINT""'");
9143 }
9144 arg7 = (PLINT)(val7);
9145 {
9146 if ( _n_dims( args(5) ) > 1 )
9147 {
9148 error( "argument must be a scalar or vector" ); SWIG_fail;
9149 }
9150 temp8 = args(5).matrix_value();
9151 arg8 = &temp8( 0, 0 );
9152 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
9153 }
9154 {
9155 if ( _n_dims( args(6) ) > 2 )
9156 {
9157 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9158 }
9159 if ( _dim( args(6), 0 ) != Xlen )
9160 {
9161 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9162 }
9163 if ( _dim( args(6), 1 ) != Ylen )
9164 {
9165 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9166 }
9167 temp10 = args(6).matrix_value();
9168 arg10 = &temp10( 0, 0 );
9169 }
9170 {
9171 if ( _n_dims( args(7) ) > 2 )
9172 {
9173 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9174 }
9175 if ( _dim( args(7), 0 ) != Xlen )
9176 {
9177 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9178 }
9179 if ( _dim( args(7), 1 ) != Ylen )
9180 {
9181 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9182 }
9183 temp11 = args(7).matrix_value();
9184 arg11 = &temp11( 0, 0 );
9185 }
9186 my_plcont2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
9187 _outv = octave_value();
9188 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9189 {
9190
9191 }
9192 {
9193
9194 }
9195 {
9196
9197 }
9198 {
9199
9200 }
9201 fail:
9202 return _out;
9203 }
9204
9205
9206 SWIG_DEFUN( plcont2p, _wrap_plcont2p, std::string() ) {
9207 PLFLT *arg1 = (PLFLT *) 0 ;
9208 PLINT arg2 ;
9209 PLINT arg3 ;
9210 PLINT arg4 ;
9211 PLINT arg5 ;
9212 PLINT arg6 ;
9213 PLINT arg7 ;
9214 PLFLT *arg8 = (PLFLT *) 0 ;
9215 PLINT arg9 ;
9216 PLFLT *arg10 = (PLFLT *) 0 ;
9217 PLFLT *arg11 = (PLFLT *) 0 ;
9218 Matrix temp1 ;
9219 int val4 ;
9220 int ecode4 = 0 ;
9221 int val5 ;
9222 int ecode5 = 0 ;
9223 int val6 ;
9224 int ecode6 = 0 ;
9225 int val7 ;
9226 int ecode7 = 0 ;
9227 Matrix temp8 ;
9228 Matrix temp10 ;
9229 Matrix temp11 ;
9230 octave_value_list _out;
9231 octave_value_list *_outp=&_out;
9232 octave_value _outv;
9233
9234 if (!SWIG_check_num_args("plcont2p",args.length(),8,8,0)) {
9235 SWIG_fail;
9236 }
9237 {
9238 if ( _n_dims( args(0) ) > 2 )
9239 {
9240 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9241 }
9242 temp1 = args(0).matrix_value();
9243 arg1 = &temp1( 0, 0 );
9244 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
9245 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
9246 }
9247 ecode4 = SWIG_AsVal_int(args(1), &val4);
9248 if (!SWIG_IsOK(ecode4)) {
9249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcont2p" "', argument " "4"" of type '" "PLINT""'");
9250 }
9251 arg4 = (PLINT)(val4);
9252 ecode5 = SWIG_AsVal_int(args(2), &val5);
9253 if (!SWIG_IsOK(ecode5)) {
9254 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcont2p" "', argument " "5"" of type '" "PLINT""'");
9255 }
9256 arg5 = (PLINT)(val5);
9257 ecode6 = SWIG_AsVal_int(args(3), &val6);
9258 if (!SWIG_IsOK(ecode6)) {
9259 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcont2p" "', argument " "6"" of type '" "PLINT""'");
9260 }
9261 arg6 = (PLINT)(val6);
9262 ecode7 = SWIG_AsVal_int(args(4), &val7);
9263 if (!SWIG_IsOK(ecode7)) {
9264 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcont2p" "', argument " "7"" of type '" "PLINT""'");
9265 }
9266 arg7 = (PLINT)(val7);
9267 {
9268 if ( _n_dims( args(5) ) > 1 )
9269 {
9270 error( "argument must be a scalar or vector" ); SWIG_fail;
9271 }
9272 temp8 = args(5).matrix_value();
9273 arg8 = &temp8( 0, 0 );
9274 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
9275 }
9276 {
9277 if ( _n_dims( args(6) ) > 2 )
9278 {
9279 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9280 }
9281 if ( _dim( args(6), 0 ) != Xlen )
9282 {
9283 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9284 }
9285 if ( _dim( args(6), 1 ) != Ylen )
9286 {
9287 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9288 }
9289 temp10 = args(6).matrix_value();
9290 arg10 = &temp10( 0, 0 );
9291 }
9292 {
9293 if ( _n_dims( args(7) ) > 2 )
9294 {
9295 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9296 }
9297 if ( _dim( args(7), 0 ) != Xlen )
9298 {
9299 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9300 }
9301 if ( _dim( args(7), 1 ) != Ylen )
9302 {
9303 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9304 }
9305 temp11 = args(7).matrix_value();
9306 arg11 = &temp11( 0, 0 );
9307 }
9308 my_plcont2p((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,(double const *)arg10,(double const *)arg11);
9309 _outv = octave_value();
9310 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9311 {
9312
9313 }
9314 {
9315
9316 }
9317 {
9318
9319 }
9320 {
9321
9322 }
9323 fail:
9324 return _out;
9325 }
9326
9327
9328 SWIG_DEFUN( plgriddata, _wrap_plgriddata, std::string() ) {
9329 PLFLT *arg1 = (PLFLT *) 0 ;
9330 PLFLT *arg2 = (PLFLT *) 0 ;
9331 PLFLT *arg3 = (PLFLT *) 0 ;
9332 PLINT arg4 ;
9333 PLFLT *arg5 = (PLFLT *) 0 ;
9334 PLINT arg6 ;
9335 PLFLT *arg7 = (PLFLT *) 0 ;
9336 PLINT arg8 ;
9337 PLFLT *arg9 = (PLFLT *) 0 ;
9338 PLINT arg10 ;
9339 PLFLT arg11 ;
9340 Matrix temp1 ;
9341 Matrix temp2 ;
9342 Matrix temp3 ;
9343 Matrix temp5 ;
9344 Matrix temp7 ;
9345 octave_value_list retval7 ;
9346 int val10 ;
9347 int ecode10 = 0 ;
9348 double val11 ;
9349 int ecode11 = 0 ;
9350 octave_value_list _out;
9351 octave_value_list *_outp=&_out;
9352 octave_value _outv;
9353
9354 if (!SWIG_check_num_args("plgriddata",args.length(),7,7,0)) {
9355 SWIG_fail;
9356 }
9357 {
9358 if ( _n_dims( args(0) ) > 1 )
9359 {
9360 error( "argument must be a scalar or vector" ); SWIG_fail;
9361 }
9362 Alen = (PLINT) ( _dim( args(0), 0 ) );
9363 temp1 = args(0).matrix_value();
9364 arg1 = &temp1( 0, 0 );
9365 }
9366 {
9367 if ( _n_dims( args(1) ) > 1 )
9368 {
9369 error( "argument must be a scalar or vector" ); SWIG_fail;
9370 }
9371 if ( _dim( args(1), 0 ) != Alen )
9372 {
9373 error( "argument vectors must be same length" ); SWIG_fail;
9374 }
9375 temp2 = args(1).matrix_value();
9376 arg2 = &temp2( 0, 0 );
9377 }
9378 {
9379 if ( _n_dims( args(2) ) > 1 )
9380 {
9381 error( "argument must be a scalar or vector" ); SWIG_fail;
9382 }
9383 if ( _dim( args(2), 0 ) != Alen )
9384 {
9385 error( "argument vectors must be same length" ); SWIG_fail;
9386 }
9387 temp3 = args(2).matrix_value();
9388 arg3 = &temp3( 0, 0 );
9389 arg4 = (PLINT) ( _dim( args(2), 0 ) );
9390 }
9391 {
9392 if ( _n_dims( args(3) ) > 1 )
9393 {
9394 error( "argument must be a scalar or vector" ); SWIG_fail;
9395 }
9396 temp5 = args(3).matrix_value();
9397 arg5 = &temp5( 0, 0 );
9398 arg6 = Xlen = (PLINT) ( _dim( args(3), 0 ) );
9399 }
9400 {
9401 if ( _n_dims( args(4) ) > 1 )
9402 {
9403 error( "argument must be a scalar or vector" ); SWIG_fail;
9404 }
9405 temp7 = args(4).matrix_value();
9406 arg7 = &temp7( 0, 0 );
9407 arg8 = Ylen = (PLINT) ( _dim( args(4), 0 ) );
9408 retval7( 0 ) = octave_value( Matrix( Xlen, Ylen ) );
9409 arg9 = (PLFLT *) retval7( 0 ).matrix_value().data();
9410 }
9411 ecode10 = SWIG_AsVal_int(args(5), &val10);
9412 if (!SWIG_IsOK(ecode10)) {
9413 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plgriddata" "', argument " "10"" of type '" "PLINT""'");
9414 }
9415 arg10 = (PLINT)(val10);
9416 ecode11 = SWIG_AsVal_double(args(6), &val11);
9417 if (!SWIG_IsOK(ecode11)) {
9418 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plgriddata" "', argument " "11"" of type '" "PLFLT""'");
9419 }
9420 arg11 = (PLFLT)(val11);
9421 my_plgriddata((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,(double const *)arg5,arg6,(double const *)arg7,arg8,arg9,arg10,arg11);
9422 _outv = octave_value();
9423 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9424 {
9425 _outp = SWIG_Octave_AppendOutput( _outp, retval7( 0 ) );
9426 }
9427 {
9428
9429 }
9430 {
9431
9432 }
9433 {
9434
9435 }
9436 {
9437
9438 }
9439 {
9440
9441 }
9442 fail:
9443 return _out;
9444 }
9445
9446
9447 SWIG_DEFUN( plmesh, _wrap_plmesh, std::string() ) {
9448 PLFLT *arg1 = (PLFLT *) 0 ;
9449 PLFLT *arg2 = (PLFLT *) 0 ;
9450 PLFLT *arg3 = (PLFLT *) 0 ;
9451 PLINT arg4 ;
9452 PLINT arg5 ;
9453 PLINT arg6 ;
9454 Matrix temp1 ;
9455 Matrix temp2 ;
9456 Matrix temp3 ;
9457 int val6 ;
9458 int ecode6 = 0 ;
9459 octave_value_list _out;
9460 octave_value_list *_outp=&_out;
9461 octave_value _outv;
9462
9463 if (!SWIG_check_num_args("plmesh",args.length(),4,4,0)) {
9464 SWIG_fail;
9465 }
9466 {
9467 if ( _n_dims( args(0) ) > 1 )
9468 {
9469 error( "argument must be a scalar or vector" ); SWIG_fail;
9470 }
9471 temp1 = args(0).matrix_value();
9472 arg1 = &temp1( 0, 0 );
9473 Xlen = (PLINT) ( _dim( args(0), 0 ) );
9474 }
9475 {
9476 if ( _n_dims( args(1) ) > 1 )
9477 {
9478 error( "argument must be a scalar or vector" ); SWIG_fail;
9479 }
9480 temp2 = args(1).matrix_value();
9481 arg2 = &temp2( 0, 0 );
9482 Ylen = (PLINT) ( _dim( args(1), 0 ) );
9483 }
9484 {
9485 if ( _n_dims( args(2) ) > 2 )
9486 {
9487 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9488 }
9489 if ( _dim( args(2), 0 ) != Xlen )
9490 {
9491 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9492 }
9493 if ( _dim( args(2), 1 ) != Ylen )
9494 {
9495 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9496 }
9497 temp3 = args(2).matrix_value();
9498 arg3 = &temp3( 0, 0 );
9499 arg4 = (PLINT) ( _dim( args(2), 0 ) );
9500 arg5 = (PLINT) ( _dim( args(2), 1 ) );
9501 }
9502 ecode6 = SWIG_AsVal_int(args(3), &val6);
9503 if (!SWIG_IsOK(ecode6)) {
9504 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmesh" "', argument " "6"" of type '" "PLINT""'");
9505 }
9506 arg6 = (PLINT)(val6);
9507 my_plmesh((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6);
9508 _outv = octave_value();
9509 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9510 {
9511
9512 }
9513 {
9514
9515 }
9516 {
9517
9518 }
9519 fail:
9520 return _out;
9521 }
9522
9523
9524 SWIG_DEFUN( plmeshc, _wrap_plmeshc, std::string() ) {
9525 PLFLT *arg1 = (PLFLT *) 0 ;
9526 PLFLT *arg2 = (PLFLT *) 0 ;
9527 PLFLT *arg3 = (PLFLT *) 0 ;
9528 PLINT arg4 ;
9529 PLINT arg5 ;
9530 PLINT arg6 ;
9531 PLFLT *arg7 = (PLFLT *) 0 ;
9532 PLINT arg8 ;
9533 Matrix temp1 ;
9534 Matrix temp2 ;
9535 Matrix temp3 ;
9536 int val6 ;
9537 int ecode6 = 0 ;
9538 Matrix temp7 ;
9539 octave_value_list _out;
9540 octave_value_list *_outp=&_out;
9541 octave_value _outv;
9542
9543 if (!SWIG_check_num_args("plmeshc",args.length(),5,5,0)) {
9544 SWIG_fail;
9545 }
9546 {
9547 if ( _n_dims( args(0) ) > 1 )
9548 {
9549 error( "argument must be a scalar or vector" ); SWIG_fail;
9550 }
9551 temp1 = args(0).matrix_value();
9552 arg1 = &temp1( 0, 0 );
9553 Xlen = (PLINT) ( _dim( args(0), 0 ) );
9554 }
9555 {
9556 if ( _n_dims( args(1) ) > 1 )
9557 {
9558 error( "argument must be a scalar or vector" ); SWIG_fail;
9559 }
9560 temp2 = args(1).matrix_value();
9561 arg2 = &temp2( 0, 0 );
9562 Ylen = (PLINT) ( _dim( args(1), 0 ) );
9563 }
9564 {
9565 if ( _n_dims( args(2) ) > 2 )
9566 {
9567 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9568 }
9569 if ( _dim( args(2), 0 ) != Xlen )
9570 {
9571 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9572 }
9573 if ( _dim( args(2), 1 ) != Ylen )
9574 {
9575 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9576 }
9577 temp3 = args(2).matrix_value();
9578 arg3 = &temp3( 0, 0 );
9579 arg4 = (PLINT) ( _dim( args(2), 0 ) );
9580 arg5 = (PLINT) ( _dim( args(2), 1 ) );
9581 }
9582 ecode6 = SWIG_AsVal_int(args(3), &val6);
9583 if (!SWIG_IsOK(ecode6)) {
9584 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeshc" "', argument " "6"" of type '" "PLINT""'");
9585 }
9586 arg6 = (PLINT)(val6);
9587 {
9588 if ( _n_dims( args(4) ) > 1 )
9589 {
9590 error( "argument must be a scalar or vector" ); SWIG_fail;
9591 }
9592 temp7 = args(4).matrix_value();
9593 arg7 = &temp7( 0, 0 );
9594 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
9595 }
9596 my_plmeshc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9597 _outv = octave_value();
9598 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9599 {
9600
9601 }
9602 {
9603
9604 }
9605 {
9606
9607 }
9608 {
9609
9610 }
9611 fail:
9612 return _out;
9613 }
9614
9615
9616 SWIG_DEFUN( plot3d, _wrap_plot3d, std::string() ) {
9617 PLFLT *arg1 = (PLFLT *) 0 ;
9618 PLFLT *arg2 = (PLFLT *) 0 ;
9619 PLFLT *arg3 = (PLFLT *) 0 ;
9620 PLINT arg4 ;
9621 PLINT arg5 ;
9622 PLINT arg6 ;
9623 PLBOOL arg7 ;
9624 Matrix temp1 ;
9625 Matrix temp2 ;
9626 Matrix temp3 ;
9627 int val6 ;
9628 int ecode6 = 0 ;
9629 int val7 ;
9630 int ecode7 = 0 ;
9631 octave_value_list _out;
9632 octave_value_list *_outp=&_out;
9633 octave_value _outv;
9634
9635 if (!SWIG_check_num_args("plot3d",args.length(),5,5,0)) {
9636 SWIG_fail;
9637 }
9638 {
9639 if ( _n_dims( args(0) ) > 1 )
9640 {
9641 error( "argument must be a scalar or vector" ); SWIG_fail;
9642 }
9643 temp1 = args(0).matrix_value();
9644 arg1 = &temp1( 0, 0 );
9645 Xlen = (PLINT) ( _dim( args(0), 0 ) );
9646 }
9647 {
9648 if ( _n_dims( args(1) ) > 1 )
9649 {
9650 error( "argument must be a scalar or vector" ); SWIG_fail;
9651 }
9652 temp2 = args(1).matrix_value();
9653 arg2 = &temp2( 0, 0 );
9654 Ylen = (PLINT) ( _dim( args(1), 0 ) );
9655 }
9656 {
9657 if ( _n_dims( args(2) ) > 2 )
9658 {
9659 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9660 }
9661 if ( _dim( args(2), 0 ) != Xlen )
9662 {
9663 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9664 }
9665 if ( _dim( args(2), 1 ) != Ylen )
9666 {
9667 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9668 }
9669 temp3 = args(2).matrix_value();
9670 arg3 = &temp3( 0, 0 );
9671 arg4 = (PLINT) ( _dim( args(2), 0 ) );
9672 arg5 = (PLINT) ( _dim( args(2), 1 ) );
9673 }
9674 ecode6 = SWIG_AsVal_int(args(3), &val6);
9675 if (!SWIG_IsOK(ecode6)) {
9676 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3d" "', argument " "6"" of type '" "PLINT""'");
9677 }
9678 arg6 = (PLINT)(val6);
9679 ecode7 = SWIG_AsVal_int(args(4), &val7);
9680 if (!SWIG_IsOK(ecode7)) {
9681 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plot3d" "', argument " "7"" of type '" "PLBOOL""'");
9682 }
9683 arg7 = (PLBOOL)(val7);
9684 my_plot3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
9685 _outv = octave_value();
9686 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9687 {
9688
9689 }
9690 {
9691
9692 }
9693 {
9694
9695 }
9696 fail:
9697 return _out;
9698 }
9699
9700
9701 SWIG_DEFUN( plot3dc, _wrap_plot3dc, std::string() ) {
9702 PLFLT *arg1 = (PLFLT *) 0 ;
9703 PLFLT *arg2 = (PLFLT *) 0 ;
9704 PLFLT *arg3 = (PLFLT *) 0 ;
9705 PLINT arg4 ;
9706 PLINT arg5 ;
9707 PLINT arg6 ;
9708 PLFLT *arg7 = (PLFLT *) 0 ;
9709 PLINT arg8 ;
9710 Matrix temp1 ;
9711 Matrix temp2 ;
9712 Matrix temp3 ;
9713 int val6 ;
9714 int ecode6 = 0 ;
9715 Matrix temp7 ;
9716 octave_value_list _out;
9717 octave_value_list *_outp=&_out;
9718 octave_value _outv;
9719
9720 if (!SWIG_check_num_args("plot3dc",args.length(),5,5,0)) {
9721 SWIG_fail;
9722 }
9723 {
9724 if ( _n_dims( args(0) ) > 1 )
9725 {
9726 error( "argument must be a scalar or vector" ); SWIG_fail;
9727 }
9728 temp1 = args(0).matrix_value();
9729 arg1 = &temp1( 0, 0 );
9730 Xlen = (PLINT) ( _dim( args(0), 0 ) );
9731 }
9732 {
9733 if ( _n_dims( args(1) ) > 1 )
9734 {
9735 error( "argument must be a scalar or vector" ); SWIG_fail;
9736 }
9737 temp2 = args(1).matrix_value();
9738 arg2 = &temp2( 0, 0 );
9739 Ylen = (PLINT) ( _dim( args(1), 0 ) );
9740 }
9741 {
9742 if ( _n_dims( args(2) ) > 2 )
9743 {
9744 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9745 }
9746 if ( _dim( args(2), 0 ) != Xlen )
9747 {
9748 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9749 }
9750 if ( _dim( args(2), 1 ) != Ylen )
9751 {
9752 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9753 }
9754 temp3 = args(2).matrix_value();
9755 arg3 = &temp3( 0, 0 );
9756 arg4 = (PLINT) ( _dim( args(2), 0 ) );
9757 arg5 = (PLINT) ( _dim( args(2), 1 ) );
9758 }
9759 ecode6 = SWIG_AsVal_int(args(3), &val6);
9760 if (!SWIG_IsOK(ecode6)) {
9761 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot3dc" "', argument " "6"" of type '" "PLINT""'");
9762 }
9763 arg6 = (PLINT)(val6);
9764 {
9765 if ( _n_dims( args(4) ) > 1 )
9766 {
9767 error( "argument must be a scalar or vector" ); SWIG_fail;
9768 }
9769 temp7 = args(4).matrix_value();
9770 arg7 = &temp7( 0, 0 );
9771 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
9772 }
9773 my_plot3dc((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9774 _outv = octave_value();
9775 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9776 {
9777
9778 }
9779 {
9780
9781 }
9782 {
9783
9784 }
9785 {
9786
9787 }
9788 fail:
9789 return _out;
9790 }
9791
9792
9793 SWIG_DEFUN( plsurf3d, _wrap_plsurf3d, std::string() ) {
9794 PLFLT *arg1 = (PLFLT *) 0 ;
9795 PLFLT *arg2 = (PLFLT *) 0 ;
9796 PLFLT *arg3 = (PLFLT *) 0 ;
9797 PLINT arg4 ;
9798 PLINT arg5 ;
9799 PLINT arg6 ;
9800 PLFLT *arg7 = (PLFLT *) 0 ;
9801 PLINT arg8 ;
9802 Matrix temp1 ;
9803 Matrix temp2 ;
9804 Matrix temp3 ;
9805 int val6 ;
9806 int ecode6 = 0 ;
9807 Matrix temp7 ;
9808 octave_value_list _out;
9809 octave_value_list *_outp=&_out;
9810 octave_value _outv;
9811
9812 if (!SWIG_check_num_args("plsurf3d",args.length(),5,5,0)) {
9813 SWIG_fail;
9814 }
9815 {
9816 if ( _n_dims( args(0) ) > 1 )
9817 {
9818 error( "argument must be a scalar or vector" ); SWIG_fail;
9819 }
9820 temp1 = args(0).matrix_value();
9821 arg1 = &temp1( 0, 0 );
9822 Xlen = (PLINT) ( _dim( args(0), 0 ) );
9823 }
9824 {
9825 if ( _n_dims( args(1) ) > 1 )
9826 {
9827 error( "argument must be a scalar or vector" ); SWIG_fail;
9828 }
9829 temp2 = args(1).matrix_value();
9830 arg2 = &temp2( 0, 0 );
9831 Ylen = (PLINT) ( _dim( args(1), 0 ) );
9832 }
9833 {
9834 if ( _n_dims( args(2) ) > 2 )
9835 {
9836 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9837 }
9838 if ( _dim( args(2), 0 ) != Xlen )
9839 {
9840 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
9841 }
9842 if ( _dim( args(2), 1 ) != Ylen )
9843 {
9844 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
9845 }
9846 temp3 = args(2).matrix_value();
9847 arg3 = &temp3( 0, 0 );
9848 arg4 = (PLINT) ( _dim( args(2), 0 ) );
9849 arg5 = (PLINT) ( _dim( args(2), 1 ) );
9850 }
9851 ecode6 = SWIG_AsVal_int(args(3), &val6);
9852 if (!SWIG_IsOK(ecode6)) {
9853 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsurf3d" "', argument " "6"" of type '" "PLINT""'");
9854 }
9855 arg6 = (PLINT)(val6);
9856 {
9857 if ( _n_dims( args(4) ) > 1 )
9858 {
9859 error( "argument must be a scalar or vector" ); SWIG_fail;
9860 }
9861 temp7 = args(4).matrix_value();
9862 arg7 = &temp7( 0, 0 );
9863 arg8 = Alen = (PLINT) ( _dim( args(4), 0 ) );
9864 }
9865 my_plsurf3d((double const *)arg1,(double const *)arg2,(double const *)arg3,arg4,arg5,arg6,(double const *)arg7,arg8);
9866 _outv = octave_value();
9867 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
9868 {
9869
9870 }
9871 {
9872
9873 }
9874 {
9875
9876 }
9877 {
9878
9879 }
9880 fail:
9881 return _out;
9882 }
9883
9884
9885 SWIG_DEFUN( plshade, _wrap_plshade, std::string() ) {
9886 PLFLT *arg1 = (PLFLT *) 0 ;
9887 PLINT arg2 ;
9888 PLINT arg3 ;
9889 PLFLT *arg4 = (PLFLT *) 0 ;
9890 PLFLT arg5 ;
9891 PLFLT arg6 ;
9892 PLFLT arg7 ;
9893 PLFLT arg8 ;
9894 PLFLT arg9 ;
9895 PLFLT arg10 ;
9896 PLINT arg11 ;
9897 PLFLT arg12 ;
9898 PLINT arg13 ;
9899 PLINT arg14 ;
9900 PLINT arg15 ;
9901 PLINT arg16 ;
9902 PLINT arg17 ;
9903 PLBOOL arg18 ;
9904 PLFLT *arg19 = (PLFLT *) 0 ;
9905 Matrix temp1 ;
9906 Matrix temp4 ;
9907 double val5 ;
9908 int ecode5 = 0 ;
9909 double val6 ;
9910 int ecode6 = 0 ;
9911 double val7 ;
9912 int ecode7 = 0 ;
9913 double val8 ;
9914 int ecode8 = 0 ;
9915 double val9 ;
9916 int ecode9 = 0 ;
9917 double val10 ;
9918 int ecode10 = 0 ;
9919 int val11 ;
9920 int ecode11 = 0 ;
9921 double val12 ;
9922 int ecode12 = 0 ;
9923 int val13 ;
9924 int ecode13 = 0 ;
9925 int val14 ;
9926 int ecode14 = 0 ;
9927 int val15 ;
9928 int ecode15 = 0 ;
9929 int val16 ;
9930 int ecode16 = 0 ;
9931 int val17 ;
9932 int ecode17 = 0 ;
9933 int val18 ;
9934 int ecode18 = 0 ;
9935 Matrix temp19 ;
9936 octave_value_list _out;
9937 octave_value_list *_outp=&_out;
9938 octave_value _outv;
9939
9940 if (!SWIG_check_num_args("plshade",args.length(),17,17,0)) {
9941 SWIG_fail;
9942 }
9943 {
9944 if ( _n_dims( args(0) ) > 2 )
9945 {
9946 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
9947 }
9948 temp1 = args(0).matrix_value();
9949 arg1 = &temp1( 0, 0 );
9950 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
9951 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
9952 }
9953 {
9954 if ( _n_dims( args(1) ) > 1 )
9955 {
9956 error( "argument must be a scalar or vector" ); SWIG_fail;
9957 }
9958 Alen = (PLINT) ( _dim( args(1), 0 ) );
9959 temp4 = args(1).matrix_value();
9960 arg4 = &temp4( 0, 0 );
9961 }
9962 ecode5 = SWIG_AsVal_double(args(2), &val5);
9963 if (!SWIG_IsOK(ecode5)) {
9964 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade" "', argument " "5"" of type '" "PLFLT""'");
9965 }
9966 arg5 = (PLFLT)(val5);
9967 ecode6 = SWIG_AsVal_double(args(3), &val6);
9968 if (!SWIG_IsOK(ecode6)) {
9969 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade" "', argument " "6"" of type '" "PLFLT""'");
9970 }
9971 arg6 = (PLFLT)(val6);
9972 ecode7 = SWIG_AsVal_double(args(4), &val7);
9973 if (!SWIG_IsOK(ecode7)) {
9974 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade" "', argument " "7"" of type '" "PLFLT""'");
9975 }
9976 arg7 = (PLFLT)(val7);
9977 ecode8 = SWIG_AsVal_double(args(5), &val8);
9978 if (!SWIG_IsOK(ecode8)) {
9979 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade" "', argument " "8"" of type '" "PLFLT""'");
9980 }
9981 arg8 = (PLFLT)(val8);
9982 ecode9 = SWIG_AsVal_double(args(6), &val9);
9983 if (!SWIG_IsOK(ecode9)) {
9984 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade" "', argument " "9"" of type '" "PLFLT""'");
9985 }
9986 arg9 = (PLFLT)(val9);
9987 ecode10 = SWIG_AsVal_double(args(7), &val10);
9988 if (!SWIG_IsOK(ecode10)) {
9989 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade" "', argument " "10"" of type '" "PLFLT""'");
9990 }
9991 arg10 = (PLFLT)(val10);
9992 ecode11 = SWIG_AsVal_int(args(8), &val11);
9993 if (!SWIG_IsOK(ecode11)) {
9994 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade" "', argument " "11"" of type '" "PLINT""'");
9995 }
9996 arg11 = (PLINT)(val11);
9997 ecode12 = SWIG_AsVal_double(args(9), &val12);
9998 if (!SWIG_IsOK(ecode12)) {
9999 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade" "', argument " "12"" of type '" "PLFLT""'");
10000 }
10001 arg12 = (PLFLT)(val12);
10002 ecode13 = SWIG_AsVal_int(args(10), &val13);
10003 if (!SWIG_IsOK(ecode13)) {
10004 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade" "', argument " "13"" of type '" "PLINT""'");
10005 }
10006 arg13 = (PLINT)(val13);
10007 ecode14 = SWIG_AsVal_int(args(11), &val14);
10008 if (!SWIG_IsOK(ecode14)) {
10009 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade" "', argument " "14"" of type '" "PLINT""'");
10010 }
10011 arg14 = (PLINT)(val14);
10012 ecode15 = SWIG_AsVal_int(args(12), &val15);
10013 if (!SWIG_IsOK(ecode15)) {
10014 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade" "', argument " "15"" of type '" "PLINT""'");
10015 }
10016 arg15 = (PLINT)(val15);
10017 ecode16 = SWIG_AsVal_int(args(13), &val16);
10018 if (!SWIG_IsOK(ecode16)) {
10019 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade" "', argument " "16"" of type '" "PLINT""'");
10020 }
10021 arg16 = (PLINT)(val16);
10022 ecode17 = SWIG_AsVal_int(args(14), &val17);
10023 if (!SWIG_IsOK(ecode17)) {
10024 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade" "', argument " "17"" of type '" "PLINT""'");
10025 }
10026 arg17 = (PLINT)(val17);
10027 ecode18 = SWIG_AsVal_int(args(15), &val18);
10028 if (!SWIG_IsOK(ecode18)) {
10029 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade" "', argument " "18"" of type '" "PLBOOL""'");
10030 }
10031 arg18 = (PLBOOL)(val18);
10032 {
10033 if ( _n_dims( args(16) ) > 1 )
10034 {
10035 error( "argument must be a scalar or vector" ); SWIG_fail;
10036 }
10037 if ( _dim( args(16), 0 ) != 6 )
10038 {
10039 error( "argument vectors must have length of 6" ); SWIG_fail;
10040 }
10041 temp19 = args(16).matrix_value();
10042 arg19 = &temp19( 0, 0 );
10043 }
10044 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);
10045 _outv = octave_value();
10046 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10047 {
10048
10049 }
10050 {
10051
10052 }
10053 {
10054
10055 }
10056 fail:
10057 return _out;
10058 }
10059
10060
10061 SWIG_DEFUN( plshade1, _wrap_plshade1, std::string() ) {
10062 PLFLT *arg1 = (PLFLT *) 0 ;
10063 PLINT arg2 ;
10064 PLINT arg3 ;
10065 char *arg4 = (char *) 0 ;
10066 PLFLT arg5 ;
10067 PLFLT arg6 ;
10068 PLFLT arg7 ;
10069 PLFLT arg8 ;
10070 PLFLT arg9 ;
10071 PLFLT arg10 ;
10072 PLINT arg11 ;
10073 PLFLT arg12 ;
10074 PLINT arg13 ;
10075 PLINT arg14 ;
10076 PLINT arg15 ;
10077 PLINT arg16 ;
10078 PLINT arg17 ;
10079 PLBOOL arg18 ;
10080 PLFLT *arg19 = (PLFLT *) 0 ;
10081 PLFLT *arg20 = (PLFLT *) 0 ;
10082 Matrix temp1 ;
10083 int res4 ;
10084 char *buf4 = 0 ;
10085 int alloc4 = 0 ;
10086 double val5 ;
10087 int ecode5 = 0 ;
10088 double val6 ;
10089 int ecode6 = 0 ;
10090 double val7 ;
10091 int ecode7 = 0 ;
10092 double val8 ;
10093 int ecode8 = 0 ;
10094 double val9 ;
10095 int ecode9 = 0 ;
10096 double val10 ;
10097 int ecode10 = 0 ;
10098 int val11 ;
10099 int ecode11 = 0 ;
10100 double val12 ;
10101 int ecode12 = 0 ;
10102 int val13 ;
10103 int ecode13 = 0 ;
10104 int val14 ;
10105 int ecode14 = 0 ;
10106 int val15 ;
10107 int ecode15 = 0 ;
10108 int val16 ;
10109 int ecode16 = 0 ;
10110 int val17 ;
10111 int ecode17 = 0 ;
10112 int val18 ;
10113 int ecode18 = 0 ;
10114 Matrix temp19 ;
10115 Matrix temp20 ;
10116 octave_value_list _out;
10117 octave_value_list *_outp=&_out;
10118 octave_value _outv;
10119
10120 if (!SWIG_check_num_args("plshade1",args.length(),18,18,0)) {
10121 SWIG_fail;
10122 }
10123 {
10124 if ( _n_dims( args(0) ) > 2 )
10125 {
10126 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10127 }
10128 temp1 = args(0).matrix_value();
10129 arg1 = &temp1( 0, 0 );
10130 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10131 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10132 }
10133 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
10134 if (!SWIG_IsOK(res4)) {
10135 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade1" "', argument " "4"" of type '" "char const *""'");
10136 }
10137 arg4 = (char *)(buf4);
10138 ecode5 = SWIG_AsVal_double(args(2), &val5);
10139 if (!SWIG_IsOK(ecode5)) {
10140 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade1" "', argument " "5"" of type '" "PLFLT""'");
10141 }
10142 arg5 = (PLFLT)(val5);
10143 ecode6 = SWIG_AsVal_double(args(3), &val6);
10144 if (!SWIG_IsOK(ecode6)) {
10145 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade1" "', argument " "6"" of type '" "PLFLT""'");
10146 }
10147 arg6 = (PLFLT)(val6);
10148 ecode7 = SWIG_AsVal_double(args(4), &val7);
10149 if (!SWIG_IsOK(ecode7)) {
10150 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade1" "', argument " "7"" of type '" "PLFLT""'");
10151 }
10152 arg7 = (PLFLT)(val7);
10153 ecode8 = SWIG_AsVal_double(args(5), &val8);
10154 if (!SWIG_IsOK(ecode8)) {
10155 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade1" "', argument " "8"" of type '" "PLFLT""'");
10156 }
10157 arg8 = (PLFLT)(val8);
10158 ecode9 = SWIG_AsVal_double(args(6), &val9);
10159 if (!SWIG_IsOK(ecode9)) {
10160 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade1" "', argument " "9"" of type '" "PLFLT""'");
10161 }
10162 arg9 = (PLFLT)(val9);
10163 ecode10 = SWIG_AsVal_double(args(7), &val10);
10164 if (!SWIG_IsOK(ecode10)) {
10165 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade1" "', argument " "10"" of type '" "PLFLT""'");
10166 }
10167 arg10 = (PLFLT)(val10);
10168 ecode11 = SWIG_AsVal_int(args(8), &val11);
10169 if (!SWIG_IsOK(ecode11)) {
10170 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade1" "', argument " "11"" of type '" "PLINT""'");
10171 }
10172 arg11 = (PLINT)(val11);
10173 ecode12 = SWIG_AsVal_double(args(9), &val12);
10174 if (!SWIG_IsOK(ecode12)) {
10175 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade1" "', argument " "12"" of type '" "PLFLT""'");
10176 }
10177 arg12 = (PLFLT)(val12);
10178 ecode13 = SWIG_AsVal_int(args(10), &val13);
10179 if (!SWIG_IsOK(ecode13)) {
10180 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade1" "', argument " "13"" of type '" "PLINT""'");
10181 }
10182 arg13 = (PLINT)(val13);
10183 ecode14 = SWIG_AsVal_int(args(11), &val14);
10184 if (!SWIG_IsOK(ecode14)) {
10185 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade1" "', argument " "14"" of type '" "PLINT""'");
10186 }
10187 arg14 = (PLINT)(val14);
10188 ecode15 = SWIG_AsVal_int(args(12), &val15);
10189 if (!SWIG_IsOK(ecode15)) {
10190 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade1" "', argument " "15"" of type '" "PLINT""'");
10191 }
10192 arg15 = (PLINT)(val15);
10193 ecode16 = SWIG_AsVal_int(args(13), &val16);
10194 if (!SWIG_IsOK(ecode16)) {
10195 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade1" "', argument " "16"" of type '" "PLINT""'");
10196 }
10197 arg16 = (PLINT)(val16);
10198 ecode17 = SWIG_AsVal_int(args(14), &val17);
10199 if (!SWIG_IsOK(ecode17)) {
10200 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade1" "', argument " "17"" of type '" "PLINT""'");
10201 }
10202 arg17 = (PLINT)(val17);
10203 ecode18 = SWIG_AsVal_int(args(15), &val18);
10204 if (!SWIG_IsOK(ecode18)) {
10205 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade1" "', argument " "18"" of type '" "PLBOOL""'");
10206 }
10207 arg18 = (PLBOOL)(val18);
10208 {
10209 if ( _n_dims( args(16) ) > 1 )
10210 {
10211 error( "argument must be a scalar or vector" ); SWIG_fail;
10212 }
10213 if ( _dim( args(16), 0 ) != Xlen )
10214 {
10215 error( "argument vectors must be same length" ); SWIG_fail;
10216 }
10217 temp19 = args(16).matrix_value();
10218 arg19 = &temp19( 0, 0 );
10219 }
10220 {
10221 if ( _n_dims( args(17) ) > 1 )
10222 {
10223 error( "argument must be a scalar or vector" ); SWIG_fail;
10224 }
10225 if ( _dim( args(17), 0 ) != Ylen )
10226 {
10227 error( "argument vectors must be same length" ); SWIG_fail;
10228 }
10229 temp20 = args(17).matrix_value();
10230 arg20 = &temp20( 0, 0 );
10231 }
10232 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);
10233 _outv = octave_value();
10234 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10235 {
10236
10237 }
10238 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10239 {
10240
10241 }
10242 {
10243
10244 }
10245 fail:
10246 return _out;
10247 }
10248
10249
10250 SWIG_DEFUN( plshade2, _wrap_plshade2, std::string() ) {
10251 PLFLT *arg1 = (PLFLT *) 0 ;
10252 PLINT arg2 ;
10253 PLINT arg3 ;
10254 char *arg4 = (char *) 0 ;
10255 PLFLT arg5 ;
10256 PLFLT arg6 ;
10257 PLFLT arg7 ;
10258 PLFLT arg8 ;
10259 PLFLT arg9 ;
10260 PLFLT arg10 ;
10261 PLINT arg11 ;
10262 PLFLT arg12 ;
10263 PLINT arg13 ;
10264 PLINT arg14 ;
10265 PLINT arg15 ;
10266 PLINT arg16 ;
10267 PLINT arg17 ;
10268 PLBOOL arg18 ;
10269 PLFLT *arg19 = (PLFLT *) 0 ;
10270 PLFLT *arg20 = (PLFLT *) 0 ;
10271 Matrix temp1 ;
10272 int res4 ;
10273 char *buf4 = 0 ;
10274 int alloc4 = 0 ;
10275 double val5 ;
10276 int ecode5 = 0 ;
10277 double val6 ;
10278 int ecode6 = 0 ;
10279 double val7 ;
10280 int ecode7 = 0 ;
10281 double val8 ;
10282 int ecode8 = 0 ;
10283 double val9 ;
10284 int ecode9 = 0 ;
10285 double val10 ;
10286 int ecode10 = 0 ;
10287 int val11 ;
10288 int ecode11 = 0 ;
10289 double val12 ;
10290 int ecode12 = 0 ;
10291 int val13 ;
10292 int ecode13 = 0 ;
10293 int val14 ;
10294 int ecode14 = 0 ;
10295 int val15 ;
10296 int ecode15 = 0 ;
10297 int val16 ;
10298 int ecode16 = 0 ;
10299 int val17 ;
10300 int ecode17 = 0 ;
10301 int val18 ;
10302 int ecode18 = 0 ;
10303 Matrix temp19 ;
10304 Matrix temp20 ;
10305 octave_value_list _out;
10306 octave_value_list *_outp=&_out;
10307 octave_value _outv;
10308
10309 if (!SWIG_check_num_args("plshade2",args.length(),18,18,0)) {
10310 SWIG_fail;
10311 }
10312 {
10313 if ( _n_dims( args(0) ) > 2 )
10314 {
10315 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10316 }
10317 temp1 = args(0).matrix_value();
10318 arg1 = &temp1( 0, 0 );
10319 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10320 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10321 }
10322 res4 = SWIG_AsCharPtrAndSize(args(1), &buf4, NULL, &alloc4);
10323 if (!SWIG_IsOK(res4)) {
10324 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plshade2" "', argument " "4"" of type '" "char const *""'");
10325 }
10326 arg4 = (char *)(buf4);
10327 ecode5 = SWIG_AsVal_double(args(2), &val5);
10328 if (!SWIG_IsOK(ecode5)) {
10329 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshade2" "', argument " "5"" of type '" "PLFLT""'");
10330 }
10331 arg5 = (PLFLT)(val5);
10332 ecode6 = SWIG_AsVal_double(args(3), &val6);
10333 if (!SWIG_IsOK(ecode6)) {
10334 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshade2" "', argument " "6"" of type '" "PLFLT""'");
10335 }
10336 arg6 = (PLFLT)(val6);
10337 ecode7 = SWIG_AsVal_double(args(4), &val7);
10338 if (!SWIG_IsOK(ecode7)) {
10339 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshade2" "', argument " "7"" of type '" "PLFLT""'");
10340 }
10341 arg7 = (PLFLT)(val7);
10342 ecode8 = SWIG_AsVal_double(args(5), &val8);
10343 if (!SWIG_IsOK(ecode8)) {
10344 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plshade2" "', argument " "8"" of type '" "PLFLT""'");
10345 }
10346 arg8 = (PLFLT)(val8);
10347 ecode9 = SWIG_AsVal_double(args(6), &val9);
10348 if (!SWIG_IsOK(ecode9)) {
10349 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plshade2" "', argument " "9"" of type '" "PLFLT""'");
10350 }
10351 arg9 = (PLFLT)(val9);
10352 ecode10 = SWIG_AsVal_double(args(7), &val10);
10353 if (!SWIG_IsOK(ecode10)) {
10354 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshade2" "', argument " "10"" of type '" "PLFLT""'");
10355 }
10356 arg10 = (PLFLT)(val10);
10357 ecode11 = SWIG_AsVal_int(args(8), &val11);
10358 if (!SWIG_IsOK(ecode11)) {
10359 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshade2" "', argument " "11"" of type '" "PLINT""'");
10360 }
10361 arg11 = (PLINT)(val11);
10362 ecode12 = SWIG_AsVal_double(args(9), &val12);
10363 if (!SWIG_IsOK(ecode12)) {
10364 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshade2" "', argument " "12"" of type '" "PLFLT""'");
10365 }
10366 arg12 = (PLFLT)(val12);
10367 ecode13 = SWIG_AsVal_int(args(10), &val13);
10368 if (!SWIG_IsOK(ecode13)) {
10369 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshade2" "', argument " "13"" of type '" "PLINT""'");
10370 }
10371 arg13 = (PLINT)(val13);
10372 ecode14 = SWIG_AsVal_int(args(11), &val14);
10373 if (!SWIG_IsOK(ecode14)) {
10374 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plshade2" "', argument " "14"" of type '" "PLINT""'");
10375 }
10376 arg14 = (PLINT)(val14);
10377 ecode15 = SWIG_AsVal_int(args(12), &val15);
10378 if (!SWIG_IsOK(ecode15)) {
10379 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plshade2" "', argument " "15"" of type '" "PLINT""'");
10380 }
10381 arg15 = (PLINT)(val15);
10382 ecode16 = SWIG_AsVal_int(args(13), &val16);
10383 if (!SWIG_IsOK(ecode16)) {
10384 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "plshade2" "', argument " "16"" of type '" "PLINT""'");
10385 }
10386 arg16 = (PLINT)(val16);
10387 ecode17 = SWIG_AsVal_int(args(14), &val17);
10388 if (!SWIG_IsOK(ecode17)) {
10389 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "plshade2" "', argument " "17"" of type '" "PLINT""'");
10390 }
10391 arg17 = (PLINT)(val17);
10392 ecode18 = SWIG_AsVal_int(args(15), &val18);
10393 if (!SWIG_IsOK(ecode18)) {
10394 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "plshade2" "', argument " "18"" of type '" "PLBOOL""'");
10395 }
10396 arg18 = (PLBOOL)(val18);
10397 {
10398 if ( _n_dims( args(16) ) > 2 )
10399 {
10400 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10401 }
10402 temp19 = args(16).matrix_value();
10403 arg19 = &temp19( 0, 0 );
10404 Xlen = (PLINT) ( _dim( args(16), 0 ) );
10405 Ylen = (PLINT) ( _dim( args(16), 1 ) );
10406 }
10407 {
10408 if ( _n_dims( args(17) ) > 2 )
10409 {
10410 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10411 }
10412 temp20 = args(17).matrix_value();
10413 arg20 = &temp20( 0, 0 );
10414 Xlen = (PLINT) ( _dim( args(17), 0 ) );
10415 Ylen = (PLINT) ( _dim( args(17), 1 ) );
10416 }
10417 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);
10418 _outv = octave_value();
10419 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10420 {
10421
10422 }
10423 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
10424 {
10425
10426 }
10427 {
10428
10429 }
10430 fail:
10431 return _out;
10432 }
10433
10434
10435 SWIG_DEFUN( plshades, _wrap_plshades, std::string() ) {
10436 PLFLT *arg1 = (PLFLT *) 0 ;
10437 PLINT arg2 ;
10438 PLINT arg3 ;
10439 PLFLT arg4 ;
10440 PLFLT arg5 ;
10441 PLFLT arg6 ;
10442 PLFLT arg7 ;
10443 PLFLT *arg8 = (PLFLT *) 0 ;
10444 PLINT arg9 ;
10445 PLINT arg10 ;
10446 PLINT arg11 ;
10447 PLINT arg12 ;
10448 PLBOOL arg13 ;
10449 Matrix temp1 ;
10450 double val4 ;
10451 int ecode4 = 0 ;
10452 double val5 ;
10453 int ecode5 = 0 ;
10454 double val6 ;
10455 int ecode6 = 0 ;
10456 double val7 ;
10457 int ecode7 = 0 ;
10458 Matrix temp8 ;
10459 int val10 ;
10460 int ecode10 = 0 ;
10461 int val11 ;
10462 int ecode11 = 0 ;
10463 int val12 ;
10464 int ecode12 = 0 ;
10465 int val13 ;
10466 int ecode13 = 0 ;
10467 octave_value_list _out;
10468 octave_value_list *_outp=&_out;
10469 octave_value _outv;
10470
10471 if (!SWIG_check_num_args("plshades",args.length(),10,10,0)) {
10472 SWIG_fail;
10473 }
10474 {
10475 if ( _n_dims( args(0) ) > 2 )
10476 {
10477 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10478 }
10479 temp1 = args(0).matrix_value();
10480 arg1 = &temp1( 0, 0 );
10481 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10482 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10483 }
10484 ecode4 = SWIG_AsVal_double(args(1), &val4);
10485 if (!SWIG_IsOK(ecode4)) {
10486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades" "', argument " "4"" of type '" "PLFLT""'");
10487 }
10488 arg4 = (PLFLT)(val4);
10489 ecode5 = SWIG_AsVal_double(args(2), &val5);
10490 if (!SWIG_IsOK(ecode5)) {
10491 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades" "', argument " "5"" of type '" "PLFLT""'");
10492 }
10493 arg5 = (PLFLT)(val5);
10494 ecode6 = SWIG_AsVal_double(args(3), &val6);
10495 if (!SWIG_IsOK(ecode6)) {
10496 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades" "', argument " "6"" of type '" "PLFLT""'");
10497 }
10498 arg6 = (PLFLT)(val6);
10499 ecode7 = SWIG_AsVal_double(args(4), &val7);
10500 if (!SWIG_IsOK(ecode7)) {
10501 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades" "', argument " "7"" of type '" "PLFLT""'");
10502 }
10503 arg7 = (PLFLT)(val7);
10504 {
10505 if ( _n_dims( args(5) ) > 1 )
10506 {
10507 error( "argument must be a scalar or vector" ); SWIG_fail;
10508 }
10509 temp8 = args(5).matrix_value();
10510 arg8 = &temp8( 0, 0 );
10511 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10512 }
10513 ecode10 = SWIG_AsVal_int(args(6), &val10);
10514 if (!SWIG_IsOK(ecode10)) {
10515 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades" "', argument " "10"" of type '" "PLINT""'");
10516 }
10517 arg10 = (PLINT)(val10);
10518 ecode11 = SWIG_AsVal_int(args(7), &val11);
10519 if (!SWIG_IsOK(ecode11)) {
10520 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades" "', argument " "11"" of type '" "PLINT""'");
10521 }
10522 arg11 = (PLINT)(val11);
10523 ecode12 = SWIG_AsVal_int(args(8), &val12);
10524 if (!SWIG_IsOK(ecode12)) {
10525 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades" "', argument " "12"" of type '" "PLINT""'");
10526 }
10527 arg12 = (PLINT)(val12);
10528 ecode13 = SWIG_AsVal_int(args(9), &val13);
10529 if (!SWIG_IsOK(ecode13)) {
10530 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades" "', argument " "13"" of type '" "PLBOOL""'");
10531 }
10532 arg13 = (PLBOOL)(val13);
10533 my_plshades((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13);
10534 _outv = octave_value();
10535 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10536 {
10537
10538 }
10539 {
10540
10541 }
10542 fail:
10543 return _out;
10544 }
10545
10546
10547 SWIG_DEFUN( plshadesx, _wrap_plshadesx, std::string() ) {
10548 PLFLT *arg1 = (PLFLT *) 0 ;
10549 PLINT arg2 ;
10550 PLINT arg3 ;
10551 PLFLT arg4 ;
10552 PLFLT arg5 ;
10553 PLFLT arg6 ;
10554 PLFLT arg7 ;
10555 PLFLT *arg8 = (PLFLT *) 0 ;
10556 PLINT arg9 ;
10557 PLINT arg10 ;
10558 PLINT arg11 ;
10559 PLINT arg12 ;
10560 PLBOOL arg13 ;
10561 PLFLT *arg14 = (PLFLT *) 0 ;
10562 Matrix temp1 ;
10563 double val4 ;
10564 int ecode4 = 0 ;
10565 double val5 ;
10566 int ecode5 = 0 ;
10567 double val6 ;
10568 int ecode6 = 0 ;
10569 double val7 ;
10570 int ecode7 = 0 ;
10571 Matrix temp8 ;
10572 int val10 ;
10573 int ecode10 = 0 ;
10574 int val11 ;
10575 int ecode11 = 0 ;
10576 int val12 ;
10577 int ecode12 = 0 ;
10578 int val13 ;
10579 int ecode13 = 0 ;
10580 Matrix temp14 ;
10581 octave_value_list _out;
10582 octave_value_list *_outp=&_out;
10583 octave_value _outv;
10584
10585 if (!SWIG_check_num_args("plshadesx",args.length(),11,11,0)) {
10586 SWIG_fail;
10587 }
10588 {
10589 if ( _n_dims( args(0) ) > 2 )
10590 {
10591 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10592 }
10593 temp1 = args(0).matrix_value();
10594 arg1 = &temp1( 0, 0 );
10595 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10596 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10597 }
10598 ecode4 = SWIG_AsVal_double(args(1), &val4);
10599 if (!SWIG_IsOK(ecode4)) {
10600 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshadesx" "', argument " "4"" of type '" "PLFLT""'");
10601 }
10602 arg4 = (PLFLT)(val4);
10603 ecode5 = SWIG_AsVal_double(args(2), &val5);
10604 if (!SWIG_IsOK(ecode5)) {
10605 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshadesx" "', argument " "5"" of type '" "PLFLT""'");
10606 }
10607 arg5 = (PLFLT)(val5);
10608 ecode6 = SWIG_AsVal_double(args(3), &val6);
10609 if (!SWIG_IsOK(ecode6)) {
10610 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshadesx" "', argument " "6"" of type '" "PLFLT""'");
10611 }
10612 arg6 = (PLFLT)(val6);
10613 ecode7 = SWIG_AsVal_double(args(4), &val7);
10614 if (!SWIG_IsOK(ecode7)) {
10615 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshadesx" "', argument " "7"" of type '" "PLFLT""'");
10616 }
10617 arg7 = (PLFLT)(val7);
10618 {
10619 if ( _n_dims( args(5) ) > 1 )
10620 {
10621 error( "argument must be a scalar or vector" ); SWIG_fail;
10622 }
10623 temp8 = args(5).matrix_value();
10624 arg8 = &temp8( 0, 0 );
10625 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10626 }
10627 ecode10 = SWIG_AsVal_int(args(6), &val10);
10628 if (!SWIG_IsOK(ecode10)) {
10629 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshadesx" "', argument " "10"" of type '" "PLINT""'");
10630 }
10631 arg10 = (PLINT)(val10);
10632 ecode11 = SWIG_AsVal_int(args(7), &val11);
10633 if (!SWIG_IsOK(ecode11)) {
10634 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshadesx" "', argument " "11"" of type '" "PLINT""'");
10635 }
10636 arg11 = (PLINT)(val11);
10637 ecode12 = SWIG_AsVal_int(args(8), &val12);
10638 if (!SWIG_IsOK(ecode12)) {
10639 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshadesx" "', argument " "12"" of type '" "PLINT""'");
10640 }
10641 arg12 = (PLINT)(val12);
10642 ecode13 = SWIG_AsVal_int(args(9), &val13);
10643 if (!SWIG_IsOK(ecode13)) {
10644 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshadesx" "', argument " "13"" of type '" "PLBOOL""'");
10645 }
10646 arg13 = (PLBOOL)(val13);
10647 {
10648 if ( _n_dims( args(10) ) > 1 )
10649 {
10650 error( "argument must be a scalar or vector" ); SWIG_fail;
10651 }
10652 if ( _dim( args(10), 0 ) != 6 )
10653 {
10654 error( "argument vectors must have length of 6" ); SWIG_fail;
10655 }
10656 temp14 = args(10).matrix_value();
10657 arg14 = &temp14( 0, 0 );
10658 }
10659 my_plshadesx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,(double const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14);
10660 _outv = octave_value();
10661 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10662 {
10663
10664 }
10665 {
10666
10667 }
10668 {
10669
10670 }
10671 fail:
10672 return _out;
10673 }
10674
10675
10676 SWIG_DEFUN( plshades1, _wrap_plshades1, std::string() ) {
10677 PLFLT *arg1 = (PLFLT *) 0 ;
10678 PLINT arg2 ;
10679 PLINT arg3 ;
10680 PLFLT arg4 ;
10681 PLFLT arg5 ;
10682 PLFLT arg6 ;
10683 PLFLT arg7 ;
10684 PLFLT *arg8 = (PLFLT *) 0 ;
10685 PLINT arg9 ;
10686 PLINT arg10 ;
10687 PLINT arg11 ;
10688 PLINT arg12 ;
10689 PLBOOL arg13 ;
10690 PLFLT *arg14 = (PLFLT *) 0 ;
10691 PLFLT *arg15 = (PLFLT *) 0 ;
10692 Matrix temp1 ;
10693 double val4 ;
10694 int ecode4 = 0 ;
10695 double val5 ;
10696 int ecode5 = 0 ;
10697 double val6 ;
10698 int ecode6 = 0 ;
10699 double val7 ;
10700 int ecode7 = 0 ;
10701 Matrix temp8 ;
10702 int val10 ;
10703 int ecode10 = 0 ;
10704 int val11 ;
10705 int ecode11 = 0 ;
10706 int val12 ;
10707 int ecode12 = 0 ;
10708 int val13 ;
10709 int ecode13 = 0 ;
10710 Matrix temp14 ;
10711 Matrix temp15 ;
10712 octave_value_list _out;
10713 octave_value_list *_outp=&_out;
10714 octave_value _outv;
10715
10716 if (!SWIG_check_num_args("plshades1",args.length(),12,12,0)) {
10717 SWIG_fail;
10718 }
10719 {
10720 if ( _n_dims( args(0) ) > 2 )
10721 {
10722 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10723 }
10724 temp1 = args(0).matrix_value();
10725 arg1 = &temp1( 0, 0 );
10726 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10727 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10728 }
10729 ecode4 = SWIG_AsVal_double(args(1), &val4);
10730 if (!SWIG_IsOK(ecode4)) {
10731 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades1" "', argument " "4"" of type '" "PLFLT""'");
10732 }
10733 arg4 = (PLFLT)(val4);
10734 ecode5 = SWIG_AsVal_double(args(2), &val5);
10735 if (!SWIG_IsOK(ecode5)) {
10736 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades1" "', argument " "5"" of type '" "PLFLT""'");
10737 }
10738 arg5 = (PLFLT)(val5);
10739 ecode6 = SWIG_AsVal_double(args(3), &val6);
10740 if (!SWIG_IsOK(ecode6)) {
10741 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades1" "', argument " "6"" of type '" "PLFLT""'");
10742 }
10743 arg6 = (PLFLT)(val6);
10744 ecode7 = SWIG_AsVal_double(args(4), &val7);
10745 if (!SWIG_IsOK(ecode7)) {
10746 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades1" "', argument " "7"" of type '" "PLFLT""'");
10747 }
10748 arg7 = (PLFLT)(val7);
10749 {
10750 if ( _n_dims( args(5) ) > 1 )
10751 {
10752 error( "argument must be a scalar or vector" ); SWIG_fail;
10753 }
10754 temp8 = args(5).matrix_value();
10755 arg8 = &temp8( 0, 0 );
10756 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10757 }
10758 ecode10 = SWIG_AsVal_int(args(6), &val10);
10759 if (!SWIG_IsOK(ecode10)) {
10760 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades1" "', argument " "10"" of type '" "PLINT""'");
10761 }
10762 arg10 = (PLINT)(val10);
10763 ecode11 = SWIG_AsVal_int(args(7), &val11);
10764 if (!SWIG_IsOK(ecode11)) {
10765 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades1" "', argument " "11"" of type '" "PLINT""'");
10766 }
10767 arg11 = (PLINT)(val11);
10768 ecode12 = SWIG_AsVal_int(args(8), &val12);
10769 if (!SWIG_IsOK(ecode12)) {
10770 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades1" "', argument " "12"" of type '" "PLINT""'");
10771 }
10772 arg12 = (PLINT)(val12);
10773 ecode13 = SWIG_AsVal_int(args(9), &val13);
10774 if (!SWIG_IsOK(ecode13)) {
10775 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades1" "', argument " "13"" of type '" "PLBOOL""'");
10776 }
10777 arg13 = (PLBOOL)(val13);
10778 {
10779 if ( _n_dims( args(10) ) > 1 )
10780 {
10781 error( "argument must be a scalar or vector" ); SWIG_fail;
10782 }
10783 if ( _dim( args(10), 0 ) != Xlen )
10784 {
10785 error( "argument vectors must be same length" ); SWIG_fail;
10786 }
10787 temp14 = args(10).matrix_value();
10788 arg14 = &temp14( 0, 0 );
10789 }
10790 {
10791 if ( _n_dims( args(11) ) > 1 )
10792 {
10793 error( "argument must be a scalar or vector" ); SWIG_fail;
10794 }
10795 if ( _dim( args(11), 0 ) != Ylen )
10796 {
10797 error( "argument vectors must be same length" ); SWIG_fail;
10798 }
10799 temp15 = args(11).matrix_value();
10800 arg15 = &temp15( 0, 0 );
10801 }
10802 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);
10803 _outv = octave_value();
10804 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10805 {
10806
10807 }
10808 {
10809
10810 }
10811 {
10812
10813 }
10814 {
10815
10816 }
10817 fail:
10818 return _out;
10819 }
10820
10821
10822 SWIG_DEFUN( plshades2, _wrap_plshades2, std::string() ) {
10823 PLFLT *arg1 = (PLFLT *) 0 ;
10824 PLINT arg2 ;
10825 PLINT arg3 ;
10826 PLFLT arg4 ;
10827 PLFLT arg5 ;
10828 PLFLT arg6 ;
10829 PLFLT arg7 ;
10830 PLFLT *arg8 = (PLFLT *) 0 ;
10831 PLINT arg9 ;
10832 PLINT arg10 ;
10833 PLINT arg11 ;
10834 PLINT arg12 ;
10835 PLBOOL arg13 ;
10836 PLFLT *arg14 = (PLFLT *) 0 ;
10837 PLFLT *arg15 = (PLFLT *) 0 ;
10838 Matrix temp1 ;
10839 double val4 ;
10840 int ecode4 = 0 ;
10841 double val5 ;
10842 int ecode5 = 0 ;
10843 double val6 ;
10844 int ecode6 = 0 ;
10845 double val7 ;
10846 int ecode7 = 0 ;
10847 Matrix temp8 ;
10848 int val10 ;
10849 int ecode10 = 0 ;
10850 int val11 ;
10851 int ecode11 = 0 ;
10852 int val12 ;
10853 int ecode12 = 0 ;
10854 int val13 ;
10855 int ecode13 = 0 ;
10856 Matrix temp14 ;
10857 Matrix temp15 ;
10858 octave_value_list _out;
10859 octave_value_list *_outp=&_out;
10860 octave_value _outv;
10861
10862 if (!SWIG_check_num_args("plshades2",args.length(),12,12,0)) {
10863 SWIG_fail;
10864 }
10865 {
10866 if ( _n_dims( args(0) ) > 2 )
10867 {
10868 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10869 }
10870 temp1 = args(0).matrix_value();
10871 arg1 = &temp1( 0, 0 );
10872 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
10873 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
10874 }
10875 ecode4 = SWIG_AsVal_double(args(1), &val4);
10876 if (!SWIG_IsOK(ecode4)) {
10877 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plshades2" "', argument " "4"" of type '" "PLFLT""'");
10878 }
10879 arg4 = (PLFLT)(val4);
10880 ecode5 = SWIG_AsVal_double(args(2), &val5);
10881 if (!SWIG_IsOK(ecode5)) {
10882 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plshades2" "', argument " "5"" of type '" "PLFLT""'");
10883 }
10884 arg5 = (PLFLT)(val5);
10885 ecode6 = SWIG_AsVal_double(args(3), &val6);
10886 if (!SWIG_IsOK(ecode6)) {
10887 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plshades2" "', argument " "6"" of type '" "PLFLT""'");
10888 }
10889 arg6 = (PLFLT)(val6);
10890 ecode7 = SWIG_AsVal_double(args(4), &val7);
10891 if (!SWIG_IsOK(ecode7)) {
10892 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plshades2" "', argument " "7"" of type '" "PLFLT""'");
10893 }
10894 arg7 = (PLFLT)(val7);
10895 {
10896 if ( _n_dims( args(5) ) > 1 )
10897 {
10898 error( "argument must be a scalar or vector" ); SWIG_fail;
10899 }
10900 temp8 = args(5).matrix_value();
10901 arg8 = &temp8( 0, 0 );
10902 arg9 = Alen = (PLINT) ( _dim( args(5), 0 ) );
10903 }
10904 ecode10 = SWIG_AsVal_int(args(6), &val10);
10905 if (!SWIG_IsOK(ecode10)) {
10906 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plshades2" "', argument " "10"" of type '" "PLINT""'");
10907 }
10908 arg10 = (PLINT)(val10);
10909 ecode11 = SWIG_AsVal_int(args(7), &val11);
10910 if (!SWIG_IsOK(ecode11)) {
10911 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plshades2" "', argument " "11"" of type '" "PLINT""'");
10912 }
10913 arg11 = (PLINT)(val11);
10914 ecode12 = SWIG_AsVal_int(args(8), &val12);
10915 if (!SWIG_IsOK(ecode12)) {
10916 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plshades2" "', argument " "12"" of type '" "PLINT""'");
10917 }
10918 arg12 = (PLINT)(val12);
10919 ecode13 = SWIG_AsVal_int(args(9), &val13);
10920 if (!SWIG_IsOK(ecode13)) {
10921 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plshades2" "', argument " "13"" of type '" "PLBOOL""'");
10922 }
10923 arg13 = (PLBOOL)(val13);
10924 {
10925 if ( _n_dims( args(10) ) > 2 )
10926 {
10927 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10928 }
10929 temp14 = args(10).matrix_value();
10930 arg14 = &temp14( 0, 0 );
10931 Xlen = (PLINT) ( _dim( args(10), 0 ) );
10932 Ylen = (PLINT) ( _dim( args(10), 1 ) );
10933 }
10934 {
10935 if ( _n_dims( args(11) ) > 2 )
10936 {
10937 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10938 }
10939 temp15 = args(11).matrix_value();
10940 arg15 = &temp15( 0, 0 );
10941 Xlen = (PLINT) ( _dim( args(11), 0 ) );
10942 Ylen = (PLINT) ( _dim( args(11), 1 ) );
10943 }
10944 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);
10945 _outv = octave_value();
10946 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
10947 {
10948
10949 }
10950 {
10951
10952 }
10953 {
10954
10955 }
10956 {
10957
10958 }
10959 fail:
10960 return _out;
10961 }
10962
10963
10964 SWIG_DEFUN( plvect, _wrap_plvect, std::string() ) {
10965 PLFLT *arg1 = (PLFLT *) 0 ;
10966 PLFLT *arg2 = (PLFLT *) 0 ;
10967 PLINT arg3 ;
10968 PLINT arg4 ;
10969 PLFLT arg5 ;
10970 PLFLT *arg6 = (PLFLT *) 0 ;
10971 Matrix temp1 ;
10972 Matrix temp2 ;
10973 double val5 ;
10974 int ecode5 = 0 ;
10975 Matrix temp6 ;
10976 octave_value_list _out;
10977 octave_value_list *_outp=&_out;
10978 octave_value _outv;
10979
10980 if (!SWIG_check_num_args("plvect",args.length(),4,4,0)) {
10981 SWIG_fail;
10982 }
10983 {
10984 if ( _n_dims( args(0) ) > 2 )
10985 {
10986 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10987 }
10988 temp1 = args(0).matrix_value();
10989 arg1 = &temp1( 0, 0 );
10990 Xlen = (PLINT) ( _dim( args(0), 0 ) );
10991 Ylen = (PLINT) ( _dim( args(0), 1 ) );
10992 }
10993 {
10994 if ( _n_dims( args(1) ) > 2 )
10995 {
10996 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
10997 }
10998 if ( _dim( args(1), 0 ) != Xlen )
10999 {
11000 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11001 }
11002 if ( _dim( args(1), 1 ) != Ylen )
11003 {
11004 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11005 }
11006 temp2 = args(1).matrix_value();
11007 arg2 = &temp2( 0, 0 );
11008 arg3 = (PLINT) ( _dim( args(1), 0 ) );
11009 arg4 = (PLINT) ( _dim( args(1), 1 ) );
11010 }
11011 ecode5 = SWIG_AsVal_double(args(2), &val5);
11012 if (!SWIG_IsOK(ecode5)) {
11013 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect" "', argument " "5"" of type '" "PLFLT""'");
11014 }
11015 arg5 = (PLFLT)(val5);
11016 {
11017 if ( _n_dims( args(3) ) > 1 )
11018 {
11019 error( "argument must be a scalar or vector" ); SWIG_fail;
11020 }
11021 if ( _dim( args(3), 0 ) != 6 )
11022 {
11023 error( "argument vectors must have length of 6" ); SWIG_fail;
11024 }
11025 temp6 = args(3).matrix_value();
11026 arg6 = &temp6( 0, 0 );
11027 }
11028 my_plvect((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
11029 _outv = octave_value();
11030 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11031 {
11032
11033 }
11034 {
11035
11036 }
11037 {
11038
11039 }
11040 fail:
11041 return _out;
11042 }
11043
11044
11045 SWIG_DEFUN( plvect1, _wrap_plvect1, std::string() ) {
11046 PLFLT *arg1 = (PLFLT *) 0 ;
11047 PLFLT *arg2 = (PLFLT *) 0 ;
11048 PLINT arg3 ;
11049 PLINT arg4 ;
11050 PLFLT arg5 ;
11051 PLFLT *arg6 = (PLFLT *) 0 ;
11052 PLFLT *arg7 = (PLFLT *) 0 ;
11053 Matrix temp1 ;
11054 Matrix temp2 ;
11055 double val5 ;
11056 int ecode5 = 0 ;
11057 Matrix temp6 ;
11058 Matrix temp7 ;
11059 octave_value_list _out;
11060 octave_value_list *_outp=&_out;
11061 octave_value _outv;
11062
11063 if (!SWIG_check_num_args("plvect1",args.length(),5,5,0)) {
11064 SWIG_fail;
11065 }
11066 {
11067 if ( _n_dims( args(0) ) > 2 )
11068 {
11069 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11070 }
11071 temp1 = args(0).matrix_value();
11072 arg1 = &temp1( 0, 0 );
11073 Xlen = (PLINT) ( _dim( args(0), 0 ) );
11074 Ylen = (PLINT) ( _dim( args(0), 1 ) );
11075 }
11076 {
11077 if ( _n_dims( args(1) ) > 2 )
11078 {
11079 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11080 }
11081 if ( _dim( args(1), 0 ) != Xlen )
11082 {
11083 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11084 }
11085 if ( _dim( args(1), 1 ) != Ylen )
11086 {
11087 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11088 }
11089 temp2 = args(1).matrix_value();
11090 arg2 = &temp2( 0, 0 );
11091 arg3 = (PLINT) ( _dim( args(1), 0 ) );
11092 arg4 = (PLINT) ( _dim( args(1), 1 ) );
11093 }
11094 ecode5 = SWIG_AsVal_double(args(2), &val5);
11095 if (!SWIG_IsOK(ecode5)) {
11096 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect1" "', argument " "5"" of type '" "PLFLT""'");
11097 }
11098 arg5 = (PLFLT)(val5);
11099 {
11100 if ( _n_dims( args(3) ) > 1 )
11101 {
11102 error( "argument must be a scalar or vector" ); SWIG_fail;
11103 }
11104 if ( _dim( args(3), 0 ) != Xlen )
11105 {
11106 error( "argument vectors must be same length" ); SWIG_fail;
11107 }
11108 temp6 = args(3).matrix_value();
11109 arg6 = &temp6( 0, 0 );
11110 }
11111 {
11112 if ( _n_dims( args(4) ) > 1 )
11113 {
11114 error( "argument must be a scalar or vector" ); SWIG_fail;
11115 }
11116 if ( _dim( args(4), 0 ) != Ylen )
11117 {
11118 error( "argument vectors must be same length" ); SWIG_fail;
11119 }
11120 temp7 = args(4).matrix_value();
11121 arg7 = &temp7( 0, 0 );
11122 }
11123 my_plvect1((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
11124 _outv = octave_value();
11125 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11126 {
11127
11128 }
11129 {
11130
11131 }
11132 {
11133
11134 }
11135 {
11136
11137 }
11138 fail:
11139 return _out;
11140 }
11141
11142
11143 SWIG_DEFUN( plvect2, _wrap_plvect2, std::string() ) {
11144 PLFLT *arg1 = (PLFLT *) 0 ;
11145 PLFLT *arg2 = (PLFLT *) 0 ;
11146 PLINT arg3 ;
11147 PLINT arg4 ;
11148 PLFLT arg5 ;
11149 PLFLT *arg6 = (PLFLT *) 0 ;
11150 PLFLT *arg7 = (PLFLT *) 0 ;
11151 Matrix temp1 ;
11152 Matrix temp2 ;
11153 double val5 ;
11154 int ecode5 = 0 ;
11155 Matrix temp6 ;
11156 Matrix temp7 ;
11157 octave_value_list _out;
11158 octave_value_list *_outp=&_out;
11159 octave_value _outv;
11160
11161 if (!SWIG_check_num_args("plvect2",args.length(),5,5,0)) {
11162 SWIG_fail;
11163 }
11164 {
11165 if ( _n_dims( args(0) ) > 2 )
11166 {
11167 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11168 }
11169 temp1 = args(0).matrix_value();
11170 arg1 = &temp1( 0, 0 );
11171 Xlen = (PLINT) ( _dim( args(0), 0 ) );
11172 Ylen = (PLINT) ( _dim( args(0), 1 ) );
11173 }
11174 {
11175 if ( _n_dims( args(1) ) > 2 )
11176 {
11177 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11178 }
11179 if ( _dim( args(1), 0 ) != Xlen )
11180 {
11181 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
11182 }
11183 if ( _dim( args(1), 1 ) != Ylen )
11184 {
11185 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
11186 }
11187 temp2 = args(1).matrix_value();
11188 arg2 = &temp2( 0, 0 );
11189 arg3 = (PLINT) ( _dim( args(1), 0 ) );
11190 arg4 = (PLINT) ( _dim( args(1), 1 ) );
11191 }
11192 ecode5 = SWIG_AsVal_double(args(2), &val5);
11193 if (!SWIG_IsOK(ecode5)) {
11194 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvect2" "', argument " "5"" of type '" "PLFLT""'");
11195 }
11196 arg5 = (PLFLT)(val5);
11197 {
11198 if ( _n_dims( args(3) ) > 2 )
11199 {
11200 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11201 }
11202 temp6 = args(3).matrix_value();
11203 arg6 = &temp6( 0, 0 );
11204 Xlen = (PLINT) ( _dim( args(3), 0 ) );
11205 Ylen = (PLINT) ( _dim( args(3), 1 ) );
11206 }
11207 {
11208 if ( _n_dims( args(4) ) > 2 )
11209 {
11210 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11211 }
11212 temp7 = args(4).matrix_value();
11213 arg7 = &temp7( 0, 0 );
11214 Xlen = (PLINT) ( _dim( args(4), 0 ) );
11215 Ylen = (PLINT) ( _dim( args(4), 1 ) );
11216 }
11217 my_plvect2((double const *)arg1,(double const *)arg2,arg3,arg4,arg5,(double const *)arg6,(double const *)arg7);
11218 _outv = octave_value();
11219 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11220 {
11221
11222 }
11223 {
11224
11225 }
11226 {
11227
11228 }
11229 {
11230
11231 }
11232 fail:
11233 return _out;
11234 }
11235
11236
11237 SWIG_DEFUN( pplimage, _wrap_pplimage, std::string() ) {
11238 PLFLT *arg1 = (PLFLT *) 0 ;
11239 PLINT arg2 ;
11240 PLINT arg3 ;
11241 PLFLT arg4 ;
11242 PLFLT arg5 ;
11243 PLFLT arg6 ;
11244 PLFLT arg7 ;
11245 PLFLT arg8 ;
11246 PLFLT arg9 ;
11247 PLFLT arg10 ;
11248 PLFLT arg11 ;
11249 PLFLT arg12 ;
11250 PLFLT arg13 ;
11251 Matrix temp1 ;
11252 double val4 ;
11253 int ecode4 = 0 ;
11254 double val5 ;
11255 int ecode5 = 0 ;
11256 double val6 ;
11257 int ecode6 = 0 ;
11258 double val7 ;
11259 int ecode7 = 0 ;
11260 double val8 ;
11261 int ecode8 = 0 ;
11262 double val9 ;
11263 int ecode9 = 0 ;
11264 double val10 ;
11265 int ecode10 = 0 ;
11266 double val11 ;
11267 int ecode11 = 0 ;
11268 double val12 ;
11269 int ecode12 = 0 ;
11270 double val13 ;
11271 int ecode13 = 0 ;
11272 octave_value_list _out;
11273 octave_value_list *_outp=&_out;
11274 octave_value _outv;
11275
11276 if (!SWIG_check_num_args("pplimage",args.length(),11,11,0)) {
11277 SWIG_fail;
11278 }
11279 {
11280 if ( _n_dims( args(0) ) > 2 )
11281 {
11282 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11283 }
11284 temp1 = args(0).matrix_value();
11285 arg1 = &temp1( 0, 0 );
11286 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11287 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11288 }
11289 ecode4 = SWIG_AsVal_double(args(1), &val4);
11290 if (!SWIG_IsOK(ecode4)) {
11291 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pplimage" "', argument " "4"" of type '" "PLFLT""'");
11292 }
11293 arg4 = (PLFLT)(val4);
11294 ecode5 = SWIG_AsVal_double(args(2), &val5);
11295 if (!SWIG_IsOK(ecode5)) {
11296 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pplimage" "', argument " "5"" of type '" "PLFLT""'");
11297 }
11298 arg5 = (PLFLT)(val5);
11299 ecode6 = SWIG_AsVal_double(args(3), &val6);
11300 if (!SWIG_IsOK(ecode6)) {
11301 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pplimage" "', argument " "6"" of type '" "PLFLT""'");
11302 }
11303 arg6 = (PLFLT)(val6);
11304 ecode7 = SWIG_AsVal_double(args(4), &val7);
11305 if (!SWIG_IsOK(ecode7)) {
11306 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pplimage" "', argument " "7"" of type '" "PLFLT""'");
11307 }
11308 arg7 = (PLFLT)(val7);
11309 ecode8 = SWIG_AsVal_double(args(5), &val8);
11310 if (!SWIG_IsOK(ecode8)) {
11311 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pplimage" "', argument " "8"" of type '" "PLFLT""'");
11312 }
11313 arg8 = (PLFLT)(val8);
11314 ecode9 = SWIG_AsVal_double(args(6), &val9);
11315 if (!SWIG_IsOK(ecode9)) {
11316 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pplimage" "', argument " "9"" of type '" "PLFLT""'");
11317 }
11318 arg9 = (PLFLT)(val9);
11319 ecode10 = SWIG_AsVal_double(args(7), &val10);
11320 if (!SWIG_IsOK(ecode10)) {
11321 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pplimage" "', argument " "10"" of type '" "PLFLT""'");
11322 }
11323 arg10 = (PLFLT)(val10);
11324 ecode11 = SWIG_AsVal_double(args(8), &val11);
11325 if (!SWIG_IsOK(ecode11)) {
11326 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pplimage" "', argument " "11"" of type '" "PLFLT""'");
11327 }
11328 arg11 = (PLFLT)(val11);
11329 ecode12 = SWIG_AsVal_double(args(9), &val12);
11330 if (!SWIG_IsOK(ecode12)) {
11331 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pplimage" "', argument " "12"" of type '" "PLFLT""'");
11332 }
11333 arg12 = (PLFLT)(val12);
11334 ecode13 = SWIG_AsVal_double(args(10), &val13);
11335 if (!SWIG_IsOK(ecode13)) {
11336 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "pplimage" "', argument " "13"" of type '" "PLFLT""'");
11337 }
11338 arg13 = (PLFLT)(val13);
11339 my_plimage((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
11340 _outv = octave_value();
11341 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11342 {
11343
11344 }
11345 fail:
11346 return _out;
11347 }
11348
11349
11350 SWIG_DEFUN( plimagefr, _wrap_plimagefr, std::string() ) {
11351 PLFLT *arg1 = (PLFLT *) 0 ;
11352 PLINT arg2 ;
11353 PLINT arg3 ;
11354 PLFLT arg4 ;
11355 PLFLT arg5 ;
11356 PLFLT arg6 ;
11357 PLFLT arg7 ;
11358 PLFLT arg8 ;
11359 PLFLT arg9 ;
11360 PLFLT arg10 ;
11361 PLFLT arg11 ;
11362 Matrix temp1 ;
11363 double val4 ;
11364 int ecode4 = 0 ;
11365 double val5 ;
11366 int ecode5 = 0 ;
11367 double val6 ;
11368 int ecode6 = 0 ;
11369 double val7 ;
11370 int ecode7 = 0 ;
11371 double val8 ;
11372 int ecode8 = 0 ;
11373 double val9 ;
11374 int ecode9 = 0 ;
11375 double val10 ;
11376 int ecode10 = 0 ;
11377 double val11 ;
11378 int ecode11 = 0 ;
11379 octave_value_list _out;
11380 octave_value_list *_outp=&_out;
11381 octave_value _outv;
11382
11383 if (!SWIG_check_num_args("plimagefr",args.length(),9,9,0)) {
11384 SWIG_fail;
11385 }
11386 {
11387 if ( _n_dims( args(0) ) > 2 )
11388 {
11389 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11390 }
11391 temp1 = args(0).matrix_value();
11392 arg1 = &temp1( 0, 0 );
11393 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11394 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11395 }
11396 ecode4 = SWIG_AsVal_double(args(1), &val4);
11397 if (!SWIG_IsOK(ecode4)) {
11398 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr" "', argument " "4"" of type '" "PLFLT""'");
11399 }
11400 arg4 = (PLFLT)(val4);
11401 ecode5 = SWIG_AsVal_double(args(2), &val5);
11402 if (!SWIG_IsOK(ecode5)) {
11403 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr" "', argument " "5"" of type '" "PLFLT""'");
11404 }
11405 arg5 = (PLFLT)(val5);
11406 ecode6 = SWIG_AsVal_double(args(3), &val6);
11407 if (!SWIG_IsOK(ecode6)) {
11408 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr" "', argument " "6"" of type '" "PLFLT""'");
11409 }
11410 arg6 = (PLFLT)(val6);
11411 ecode7 = SWIG_AsVal_double(args(4), &val7);
11412 if (!SWIG_IsOK(ecode7)) {
11413 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr" "', argument " "7"" of type '" "PLFLT""'");
11414 }
11415 arg7 = (PLFLT)(val7);
11416 ecode8 = SWIG_AsVal_double(args(5), &val8);
11417 if (!SWIG_IsOK(ecode8)) {
11418 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr" "', argument " "8"" of type '" "PLFLT""'");
11419 }
11420 arg8 = (PLFLT)(val8);
11421 ecode9 = SWIG_AsVal_double(args(6), &val9);
11422 if (!SWIG_IsOK(ecode9)) {
11423 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr" "', argument " "9"" of type '" "PLFLT""'");
11424 }
11425 arg9 = (PLFLT)(val9);
11426 ecode10 = SWIG_AsVal_double(args(7), &val10);
11427 if (!SWIG_IsOK(ecode10)) {
11428 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr" "', argument " "10"" of type '" "PLFLT""'");
11429 }
11430 arg10 = (PLFLT)(val10);
11431 ecode11 = SWIG_AsVal_double(args(8), &val11);
11432 if (!SWIG_IsOK(ecode11)) {
11433 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr" "', argument " "11"" of type '" "PLFLT""'");
11434 }
11435 arg11 = (PLFLT)(val11);
11436 my_plimagefr((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
11437 _outv = octave_value();
11438 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11439 {
11440
11441 }
11442 fail:
11443 return _out;
11444 }
11445
11446
11447 SWIG_DEFUN( plimagefrx, _wrap_plimagefrx, std::string() ) {
11448 PLFLT *arg1 = (PLFLT *) 0 ;
11449 PLINT arg2 ;
11450 PLINT arg3 ;
11451 PLFLT arg4 ;
11452 PLFLT arg5 ;
11453 PLFLT arg6 ;
11454 PLFLT arg7 ;
11455 PLFLT arg8 ;
11456 PLFLT arg9 ;
11457 PLFLT arg10 ;
11458 PLFLT arg11 ;
11459 PLFLT *arg12 = (PLFLT *) 0 ;
11460 Matrix temp1 ;
11461 double val4 ;
11462 int ecode4 = 0 ;
11463 double val5 ;
11464 int ecode5 = 0 ;
11465 double val6 ;
11466 int ecode6 = 0 ;
11467 double val7 ;
11468 int ecode7 = 0 ;
11469 double val8 ;
11470 int ecode8 = 0 ;
11471 double val9 ;
11472 int ecode9 = 0 ;
11473 double val10 ;
11474 int ecode10 = 0 ;
11475 double val11 ;
11476 int ecode11 = 0 ;
11477 Matrix temp12 ;
11478 octave_value_list _out;
11479 octave_value_list *_outp=&_out;
11480 octave_value _outv;
11481
11482 if (!SWIG_check_num_args("plimagefrx",args.length(),10,10,0)) {
11483 SWIG_fail;
11484 }
11485 {
11486 if ( _n_dims( args(0) ) > 2 )
11487 {
11488 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11489 }
11490 temp1 = args(0).matrix_value();
11491 arg1 = &temp1( 0, 0 );
11492 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11493 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11494 }
11495 ecode4 = SWIG_AsVal_double(args(1), &val4);
11496 if (!SWIG_IsOK(ecode4)) {
11497 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefrx" "', argument " "4"" of type '" "PLFLT""'");
11498 }
11499 arg4 = (PLFLT)(val4);
11500 ecode5 = SWIG_AsVal_double(args(2), &val5);
11501 if (!SWIG_IsOK(ecode5)) {
11502 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefrx" "', argument " "5"" of type '" "PLFLT""'");
11503 }
11504 arg5 = (PLFLT)(val5);
11505 ecode6 = SWIG_AsVal_double(args(3), &val6);
11506 if (!SWIG_IsOK(ecode6)) {
11507 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefrx" "', argument " "6"" of type '" "PLFLT""'");
11508 }
11509 arg6 = (PLFLT)(val6);
11510 ecode7 = SWIG_AsVal_double(args(4), &val7);
11511 if (!SWIG_IsOK(ecode7)) {
11512 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefrx" "', argument " "7"" of type '" "PLFLT""'");
11513 }
11514 arg7 = (PLFLT)(val7);
11515 ecode8 = SWIG_AsVal_double(args(5), &val8);
11516 if (!SWIG_IsOK(ecode8)) {
11517 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefrx" "', argument " "8"" of type '" "PLFLT""'");
11518 }
11519 arg8 = (PLFLT)(val8);
11520 ecode9 = SWIG_AsVal_double(args(6), &val9);
11521 if (!SWIG_IsOK(ecode9)) {
11522 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefrx" "', argument " "9"" of type '" "PLFLT""'");
11523 }
11524 arg9 = (PLFLT)(val9);
11525 ecode10 = SWIG_AsVal_double(args(7), &val10);
11526 if (!SWIG_IsOK(ecode10)) {
11527 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefrx" "', argument " "10"" of type '" "PLFLT""'");
11528 }
11529 arg10 = (PLFLT)(val10);
11530 ecode11 = SWIG_AsVal_double(args(8), &val11);
11531 if (!SWIG_IsOK(ecode11)) {
11532 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefrx" "', argument " "11"" of type '" "PLFLT""'");
11533 }
11534 arg11 = (PLFLT)(val11);
11535 {
11536 if ( _n_dims( args(9) ) > 1 )
11537 {
11538 error( "argument must be a scalar or vector" ); SWIG_fail;
11539 }
11540 if ( _dim( args(9), 0 ) != 6 )
11541 {
11542 error( "argument vectors must have length of 6" ); SWIG_fail;
11543 }
11544 temp12 = args(9).matrix_value();
11545 arg12 = &temp12( 0, 0 );
11546 }
11547 my_plimagefrx((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
11548 _outv = octave_value();
11549 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11550 {
11551
11552 }
11553 {
11554
11555 }
11556 fail:
11557 return _out;
11558 }
11559
11560
11561 SWIG_DEFUN( plimagefr1, _wrap_plimagefr1, std::string() ) {
11562 PLFLT *arg1 = (PLFLT *) 0 ;
11563 PLINT arg2 ;
11564 PLINT arg3 ;
11565 PLFLT arg4 ;
11566 PLFLT arg5 ;
11567 PLFLT arg6 ;
11568 PLFLT arg7 ;
11569 PLFLT arg8 ;
11570 PLFLT arg9 ;
11571 PLFLT arg10 ;
11572 PLFLT arg11 ;
11573 PLFLT *arg12 = (PLFLT *) 0 ;
11574 PLFLT *arg13 = (PLFLT *) 0 ;
11575 Matrix temp1 ;
11576 double val4 ;
11577 int ecode4 = 0 ;
11578 double val5 ;
11579 int ecode5 = 0 ;
11580 double val6 ;
11581 int ecode6 = 0 ;
11582 double val7 ;
11583 int ecode7 = 0 ;
11584 double val8 ;
11585 int ecode8 = 0 ;
11586 double val9 ;
11587 int ecode9 = 0 ;
11588 double val10 ;
11589 int ecode10 = 0 ;
11590 double val11 ;
11591 int ecode11 = 0 ;
11592 Matrix temp12 ;
11593 Matrix temp13 ;
11594 octave_value_list _out;
11595 octave_value_list *_outp=&_out;
11596 octave_value _outv;
11597
11598 if (!SWIG_check_num_args("plimagefr1",args.length(),11,11,0)) {
11599 SWIG_fail;
11600 }
11601 {
11602 if ( _n_dims( args(0) ) > 2 )
11603 {
11604 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11605 }
11606 temp1 = args(0).matrix_value();
11607 arg1 = &temp1( 0, 0 );
11608 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11609 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11610 }
11611 ecode4 = SWIG_AsVal_double(args(1), &val4);
11612 if (!SWIG_IsOK(ecode4)) {
11613 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr1" "', argument " "4"" of type '" "PLFLT""'");
11614 }
11615 arg4 = (PLFLT)(val4);
11616 ecode5 = SWIG_AsVal_double(args(2), &val5);
11617 if (!SWIG_IsOK(ecode5)) {
11618 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr1" "', argument " "5"" of type '" "PLFLT""'");
11619 }
11620 arg5 = (PLFLT)(val5);
11621 ecode6 = SWIG_AsVal_double(args(3), &val6);
11622 if (!SWIG_IsOK(ecode6)) {
11623 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr1" "', argument " "6"" of type '" "PLFLT""'");
11624 }
11625 arg6 = (PLFLT)(val6);
11626 ecode7 = SWIG_AsVal_double(args(4), &val7);
11627 if (!SWIG_IsOK(ecode7)) {
11628 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr1" "', argument " "7"" of type '" "PLFLT""'");
11629 }
11630 arg7 = (PLFLT)(val7);
11631 ecode8 = SWIG_AsVal_double(args(5), &val8);
11632 if (!SWIG_IsOK(ecode8)) {
11633 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr1" "', argument " "8"" of type '" "PLFLT""'");
11634 }
11635 arg8 = (PLFLT)(val8);
11636 ecode9 = SWIG_AsVal_double(args(6), &val9);
11637 if (!SWIG_IsOK(ecode9)) {
11638 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr1" "', argument " "9"" of type '" "PLFLT""'");
11639 }
11640 arg9 = (PLFLT)(val9);
11641 ecode10 = SWIG_AsVal_double(args(7), &val10);
11642 if (!SWIG_IsOK(ecode10)) {
11643 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr1" "', argument " "10"" of type '" "PLFLT""'");
11644 }
11645 arg10 = (PLFLT)(val10);
11646 ecode11 = SWIG_AsVal_double(args(8), &val11);
11647 if (!SWIG_IsOK(ecode11)) {
11648 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr1" "', argument " "11"" of type '" "PLFLT""'");
11649 }
11650 arg11 = (PLFLT)(val11);
11651 {
11652 if ( _n_dims( args(9) ) > 1 )
11653 {
11654 error( "argument must be a scalar or vector" ); SWIG_fail;
11655 }
11656 if ( _dim( args(9), 0 ) != Xlen )
11657 {
11658 error( "argument vectors must be same length" ); SWIG_fail;
11659 }
11660 temp12 = args(9).matrix_value();
11661 arg12 = &temp12( 0, 0 );
11662 }
11663 {
11664 if ( _n_dims( args(10) ) > 1 )
11665 {
11666 error( "argument must be a scalar or vector" ); SWIG_fail;
11667 }
11668 if ( _dim( args(10), 0 ) != Ylen )
11669 {
11670 error( "argument vectors must be same length" ); SWIG_fail;
11671 }
11672 temp13 = args(10).matrix_value();
11673 arg13 = &temp13( 0, 0 );
11674 }
11675 my_plimagefr1((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
11676 _outv = octave_value();
11677 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11678 {
11679
11680 }
11681 {
11682
11683 }
11684 {
11685
11686 }
11687 fail:
11688 return _out;
11689 }
11690
11691
11692 SWIG_DEFUN( plimagefr2, _wrap_plimagefr2, std::string() ) {
11693 PLFLT *arg1 = (PLFLT *) 0 ;
11694 PLINT arg2 ;
11695 PLINT arg3 ;
11696 PLFLT arg4 ;
11697 PLFLT arg5 ;
11698 PLFLT arg6 ;
11699 PLFLT arg7 ;
11700 PLFLT arg8 ;
11701 PLFLT arg9 ;
11702 PLFLT arg10 ;
11703 PLFLT arg11 ;
11704 PLFLT *arg12 = (PLFLT *) 0 ;
11705 PLFLT *arg13 = (PLFLT *) 0 ;
11706 Matrix temp1 ;
11707 double val4 ;
11708 int ecode4 = 0 ;
11709 double val5 ;
11710 int ecode5 = 0 ;
11711 double val6 ;
11712 int ecode6 = 0 ;
11713 double val7 ;
11714 int ecode7 = 0 ;
11715 double val8 ;
11716 int ecode8 = 0 ;
11717 double val9 ;
11718 int ecode9 = 0 ;
11719 double val10 ;
11720 int ecode10 = 0 ;
11721 double val11 ;
11722 int ecode11 = 0 ;
11723 Matrix temp12 ;
11724 Matrix temp13 ;
11725 octave_value_list _out;
11726 octave_value_list *_outp=&_out;
11727 octave_value _outv;
11728
11729 if (!SWIG_check_num_args("plimagefr2",args.length(),11,11,0)) {
11730 SWIG_fail;
11731 }
11732 {
11733 if ( _n_dims( args(0) ) > 2 )
11734 {
11735 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11736 }
11737 temp1 = args(0).matrix_value();
11738 arg1 = &temp1( 0, 0 );
11739 arg2 = Xlen = (PLINT) ( _dim( args(0), 0 ) );
11740 arg3 = Ylen = (PLINT) ( _dim( args(0), 1 ) );
11741 }
11742 ecode4 = SWIG_AsVal_double(args(1), &val4);
11743 if (!SWIG_IsOK(ecode4)) {
11744 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plimagefr2" "', argument " "4"" of type '" "PLFLT""'");
11745 }
11746 arg4 = (PLFLT)(val4);
11747 ecode5 = SWIG_AsVal_double(args(2), &val5);
11748 if (!SWIG_IsOK(ecode5)) {
11749 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plimagefr2" "', argument " "5"" of type '" "PLFLT""'");
11750 }
11751 arg5 = (PLFLT)(val5);
11752 ecode6 = SWIG_AsVal_double(args(3), &val6);
11753 if (!SWIG_IsOK(ecode6)) {
11754 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plimagefr2" "', argument " "6"" of type '" "PLFLT""'");
11755 }
11756 arg6 = (PLFLT)(val6);
11757 ecode7 = SWIG_AsVal_double(args(4), &val7);
11758 if (!SWIG_IsOK(ecode7)) {
11759 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plimagefr2" "', argument " "7"" of type '" "PLFLT""'");
11760 }
11761 arg7 = (PLFLT)(val7);
11762 ecode8 = SWIG_AsVal_double(args(5), &val8);
11763 if (!SWIG_IsOK(ecode8)) {
11764 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plimagefr2" "', argument " "8"" of type '" "PLFLT""'");
11765 }
11766 arg8 = (PLFLT)(val8);
11767 ecode9 = SWIG_AsVal_double(args(6), &val9);
11768 if (!SWIG_IsOK(ecode9)) {
11769 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plimagefr2" "', argument " "9"" of type '" "PLFLT""'");
11770 }
11771 arg9 = (PLFLT)(val9);
11772 ecode10 = SWIG_AsVal_double(args(7), &val10);
11773 if (!SWIG_IsOK(ecode10)) {
11774 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plimagefr2" "', argument " "10"" of type '" "PLFLT""'");
11775 }
11776 arg10 = (PLFLT)(val10);
11777 ecode11 = SWIG_AsVal_double(args(8), &val11);
11778 if (!SWIG_IsOK(ecode11)) {
11779 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plimagefr2" "', argument " "11"" of type '" "PLFLT""'");
11780 }
11781 arg11 = (PLFLT)(val11);
11782 {
11783 if ( _n_dims( args(9) ) > 2 )
11784 {
11785 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11786 }
11787 temp12 = args(9).matrix_value();
11788 arg12 = &temp12( 0, 0 );
11789 Xlen = (PLINT) ( _dim( args(9), 0 ) );
11790 Ylen = (PLINT) ( _dim( args(9), 1 ) );
11791 }
11792 {
11793 if ( _n_dims( args(10) ) > 2 )
11794 {
11795 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
11796 }
11797 temp13 = args(10).matrix_value();
11798 arg13 = &temp13( 0, 0 );
11799 Xlen = (PLINT) ( _dim( args(10), 0 ) );
11800 Ylen = (PLINT) ( _dim( args(10), 1 ) );
11801 }
11802 my_plimagefr2((double const *)arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(double const *)arg12,(double const *)arg13);
11803 _outv = octave_value();
11804 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
11805 {
11806
11807 }
11808 {
11809
11810 }
11811 {
11812
11813 }
11814 fail:
11815 return _out;
11816 }
11817
11818
11819 SWIG_DEFUN( plcolorbar, _wrap_plcolorbar, std::string() ) {
11820 PLFLT *arg1 = (PLFLT *) 0 ;
11821 PLFLT *arg2 = (PLFLT *) 0 ;
11822 PLINT arg3 ;
11823 PLINT arg4 ;
11824 PLFLT arg5 ;
11825 PLFLT arg6 ;
11826 PLFLT arg7 ;
11827 PLFLT arg8 ;
11828 PLINT arg9 ;
11829 PLINT arg10 ;
11830 PLINT arg11 ;
11831 PLFLT arg12 ;
11832 PLFLT arg13 ;
11833 PLINT arg14 ;
11834 PLFLT arg15 ;
11835 PLINT arg16 ;
11836 PLINT *arg17 = (PLINT *) 0 ;
11837 char **arg18 = (char **) 0 ;
11838 PLINT arg19 ;
11839 char **arg20 = (char **) 0 ;
11840 PLFLT *arg21 = (PLFLT *) 0 ;
11841 PLINT *arg22 = (PLINT *) 0 ;
11842 PLINT *arg23 = (PLINT *) 0 ;
11843 PLFLT *arg24 = (PLFLT *) 0 ;
11844 PLFLT temp1 ;
11845 int res1 = SWIG_TMPOBJ ;
11846 PLFLT temp2 ;
11847 int res2 = SWIG_TMPOBJ ;
11848 int val3 ;
11849 int ecode3 = 0 ;
11850 int val4 ;
11851 int ecode4 = 0 ;
11852 double val5 ;
11853 int ecode5 = 0 ;
11854 double val6 ;
11855 int ecode6 = 0 ;
11856 double val7 ;
11857 int ecode7 = 0 ;
11858 double val8 ;
11859 int ecode8 = 0 ;
11860 int val9 ;
11861 int ecode9 = 0 ;
11862 int val10 ;
11863 int ecode10 = 0 ;
11864 int val11 ;
11865 int ecode11 = 0 ;
11866 double val12 ;
11867 int ecode12 = 0 ;
11868 double val13 ;
11869 int ecode13 = 0 ;
11870 int val14 ;
11871 int ecode14 = 0 ;
11872 double val15 ;
11873 int ecode15 = 0 ;
11874 Matrix temp16 ;
11875 Matrix temp21 ;
11876 Matrix temp22 ;
11877 Matrix temp23 ;
11878 Matrix temp24 ;
11879 octave_value_list _out;
11880 octave_value_list *_outp=&_out;
11881 octave_value _outv;
11882
11883 arg1 = &temp1;
11884 arg2 = &temp2;
11885 if (!SWIG_check_num_args("plcolorbar",args.length(),20,20,0)) {
11886 SWIG_fail;
11887 }
11888 ecode3 = SWIG_AsVal_int(args(0), &val3);
11889 if (!SWIG_IsOK(ecode3)) {
11890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plcolorbar" "', argument " "3"" of type '" "PLINT""'");
11891 }
11892 arg3 = (PLINT)(val3);
11893 ecode4 = SWIG_AsVal_int(args(1), &val4);
11894 if (!SWIG_IsOK(ecode4)) {
11895 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plcolorbar" "', argument " "4"" of type '" "PLINT""'");
11896 }
11897 arg4 = (PLINT)(val4);
11898 ecode5 = SWIG_AsVal_double(args(2), &val5);
11899 if (!SWIG_IsOK(ecode5)) {
11900 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plcolorbar" "', argument " "5"" of type '" "PLFLT""'");
11901 }
11902 arg5 = (PLFLT)(val5);
11903 ecode6 = SWIG_AsVal_double(args(3), &val6);
11904 if (!SWIG_IsOK(ecode6)) {
11905 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plcolorbar" "', argument " "6"" of type '" "PLFLT""'");
11906 }
11907 arg6 = (PLFLT)(val6);
11908 ecode7 = SWIG_AsVal_double(args(4), &val7);
11909 if (!SWIG_IsOK(ecode7)) {
11910 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plcolorbar" "', argument " "7"" of type '" "PLFLT""'");
11911 }
11912 arg7 = (PLFLT)(val7);
11913 ecode8 = SWIG_AsVal_double(args(5), &val8);
11914 if (!SWIG_IsOK(ecode8)) {
11915 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plcolorbar" "', argument " "8"" of type '" "PLFLT""'");
11916 }
11917 arg8 = (PLFLT)(val8);
11918 ecode9 = SWIG_AsVal_int(args(6), &val9);
11919 if (!SWIG_IsOK(ecode9)) {
11920 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plcolorbar" "', argument " "9"" of type '" "PLINT""'");
11921 }
11922 arg9 = (PLINT)(val9);
11923 ecode10 = SWIG_AsVal_int(args(7), &val10);
11924 if (!SWIG_IsOK(ecode10)) {
11925 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plcolorbar" "', argument " "10"" of type '" "PLINT""'");
11926 }
11927 arg10 = (PLINT)(val10);
11928 ecode11 = SWIG_AsVal_int(args(8), &val11);
11929 if (!SWIG_IsOK(ecode11)) {
11930 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plcolorbar" "', argument " "11"" of type '" "PLINT""'");
11931 }
11932 arg11 = (PLINT)(val11);
11933 ecode12 = SWIG_AsVal_double(args(9), &val12);
11934 if (!SWIG_IsOK(ecode12)) {
11935 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plcolorbar" "', argument " "12"" of type '" "PLFLT""'");
11936 }
11937 arg12 = (PLFLT)(val12);
11938 ecode13 = SWIG_AsVal_double(args(10), &val13);
11939 if (!SWIG_IsOK(ecode13)) {
11940 SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "plcolorbar" "', argument " "13"" of type '" "PLFLT""'");
11941 }
11942 arg13 = (PLFLT)(val13);
11943 ecode14 = SWIG_AsVal_int(args(11), &val14);
11944 if (!SWIG_IsOK(ecode14)) {
11945 SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "plcolorbar" "', argument " "14"" of type '" "PLINT""'");
11946 }
11947 arg14 = (PLINT)(val14);
11948 ecode15 = SWIG_AsVal_double(args(12), &val15);
11949 if (!SWIG_IsOK(ecode15)) {
11950 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "plcolorbar" "', argument " "15"" of type '" "PLFLT""'");
11951 }
11952 arg15 = (PLFLT)(val15);
11953 {
11954 if ( _n_dims( args(13) ) > 1 )
11955 {
11956 error( "argument must be a scalar or vector" ); SWIG_fail;
11957 }
11958 arg16 = Alen = (PLINT) ( _dim( args(13), 0 ) );
11959 arg17 = new PLINT[Alen];
11960 temp16 = args(13).matrix_value();
11961 _cvt_double_to( arg17, &temp16( 0, 0 ), Alen );
11962 }
11963 {
11964 charMatrix temp_matrix;
11965 Cell temp_cell;
11966 char *tmp_cstring;
11967 std::string str;
11968 size_t max_length = 0, non_blank_length;
11969 int i, ifcell;
11970 if ( _n_dims( args(14) ) > 2 )
11971 {
11972 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
11973 }
11974 if ( !args(14).is_empty() )
11975 {
11976 if ( _dim( args(14), 0 ) != Alen )
11977 {
11978 error( "first dimension must be same length as previous vector" ); SWIG_fail;
11979 }
11980 arg18 = new char*[Alen];
11981 ifcell = args(14).is_cell();
11982 if ( ifcell )
11983 {
11984 temp_cell = args(14).cell_value();
11985 }
11986 else
11987 {
11988 temp_matrix = args(14).char_matrix_value();
11989 // Allow one extra space for null termination.
11990 max_length = _dim( args(14), 1 ) + 1;
11991 }
11992
11993 for ( i = 0; i < Alen; i++ )
11994 {
11995 // Must copy string to "permanent" location because the string
11996 // location corresponding to tmp_cstring gets
11997 // overwritten for each iteration of loop.
11998 if ( ifcell )
11999 {
12000 if ( temp_cell.elem( i ).is_string() )
12001 {
12002 str = temp_cell.elem( i ).string_value();
12003 // leave room for null termination.
12004 max_length = str.size() + 1;
12005 tmp_cstring = (char *) str.c_str();
12006 }
12007 else
12008 {
12009 // Use null string if user attempts to pass a cell array
12010 // with a non-string element (likely an empty element
12011 // since that should be allowed by the PLplot interface
12012 // if that element is going to be unused).
12013 // leave room for null termination.
12014 max_length = 1;
12015 tmp_cstring = (char *) "";
12016 }
12017 }
12018 else
12019 {
12020 tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
12021 }
12022 arg18[i] = new char[max_length];
12023 strncpy( arg18[i], tmp_cstring, max_length - 1 );
12024 arg18[i][max_length - 1] = '\0';
12025 // All the trailing blank crapola should not be needed for
12026 // string cell arrays.
12027 if ( !ifcell )
12028 {
12029 // remove trailing-blank padding that is used by the
12030 // charMatrix class to insure all strings in a given
12031 // charMatrix instance have the same length.
12032 // This transformation also removes legitimate trailing
12033 // blanks but there is nothing we can do about that
12034 // for the charMatrix class.
12035
12036 // Look for trailing nulls first (just in case, although that
12037 // shouldn't happen if charMatrix implemented as documented)
12038 // before looking for trailing blanks.
12039 non_blank_length = max_length - 2;
12040 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == '\0' )
12041 {
12042 non_blank_length--;
12043 }
12044 while ( non_blank_length >= 0 && arg18[i][non_blank_length] == ' ' )
12045 {
12046 non_blank_length--;
12047 }
12048 arg18[i][non_blank_length + 1] = '\0';
12049 }
12050 }
12051 }
12052 else
12053 {
12054 arg18 = NULL;
12055 }
12056 }
12057 {
12058 charMatrix temp_matrix;
12059 Cell temp_cell;
12060 char *tmp_cstring;
12061 std::string str;
12062 size_t max_length = 0, non_blank_length;
12063 int i, ifcell;
12064 if ( _n_dims( args(15) ) > 2 )
12065 {
12066 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
12067 }
12068 if ( !args(15).is_empty() )
12069 {
12070 Alen = _dim( args(15), 0 );
12071 arg19 = Alen;
12072 arg20 = new char*[Alen];
12073 ifcell = args(15).is_cell();
12074 if ( ifcell )
12075 {
12076 temp_cell = args(15).cell_value();
12077 }
12078 else
12079 {
12080 temp_matrix = args(15).char_matrix_value();
12081 // Allow one extra space for null termination.
12082 max_length = _dim( args(15), 1 ) + 1;
12083 }
12084
12085 for ( i = 0; i < Alen; i++ )
12086 {
12087 // Must copy string to "permanent" location because the string
12088 // location corresponding to tmp_cstring gets
12089 // overwritten for each iteration of loop.
12090 if ( ifcell )
12091 {
12092 if ( temp_cell.elem( i ).is_string() )
12093 {
12094 str = temp_cell.elem( i ).string_value();
12095 // leave room for null termination.
12096 max_length = str.size() + 1;
12097 tmp_cstring = (char *) str.c_str();
12098 }
12099 else
12100 {
12101 // Use null string if user attempts to pass a cell array
12102 // with a non-string element (likely an empty element
12103 // since that should be allowed by the PLplot interface
12104 // if that element is going to be unused).
12105 // leave room for null termination.
12106 max_length = 1;
12107 tmp_cstring = (char *) "";
12108 }
12109 }
12110 else
12111 {
12112 tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
12113 }
12114 arg20[i] = new char[max_length];
12115 strncpy( arg20[i], tmp_cstring, max_length - 1 );
12116 arg20[i][max_length - 1] = '\0';
12117 // All the trailing blank crapola should not be needed for
12118 // string cell arrays.
12119 if ( !ifcell )
12120 {
12121 // remove trailing-blank padding that is used by the
12122 // charMatrix class to insure all strings in a given
12123 // charMatrix instance have the same length.
12124 // This transformation also removes legitimate trailing
12125 // blanks but there is nothing we can do about that
12126 // for the charMatrix class.
12127
12128 // Look for trailing nulls first (just in case, although that
12129 // shouldn't happen if charMatrix implemented as documented)
12130 // before looking for trailing blanks.
12131 non_blank_length = max_length - 2;
12132 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
12133 {
12134 non_blank_length--;
12135 }
12136 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
12137 {
12138 non_blank_length--;
12139 }
12140 arg20[i][non_blank_length + 1] = '\0';
12141 }
12142 }
12143 }
12144 else
12145 {
12146 arg19 = 0;
12147 arg20 = NULL;
12148 }
12149 }
12150 {
12151 if ( _n_dims( args(16) ) > 1 )
12152 {
12153 error( "argument must be a scalar or vector" ); SWIG_fail;
12154 }
12155 if ( _dim( args(16), 0 ) != Alen )
12156 {
12157 error( "argument vectors must be same length" ); SWIG_fail;
12158 }
12159 temp21 = args(16).matrix_value();
12160 arg21 = &temp21( 0, 0 );
12161 }
12162 {
12163 if ( _n_dims( args(17) ) > 1 )
12164 {
12165 error( "argument must be a scalar or vector" ); SWIG_fail;
12166 }
12167 if ( _dim( args(17), 0 ) != Alen )
12168 {
12169 error( "argument vectors must be same length" ); SWIG_fail;
12170 }
12171 temp22 = args(17).matrix_value();
12172 arg22 = new PLINT[Alen];
12173 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
12174 }
12175 {
12176 int i;
12177 if ( _n_dims( args(18) ) > 1 )
12178 {
12179 error( "argument must be a scalar or vector" ); SWIG_fail;
12180 }
12181 if ( _dim( args(18), 0 ) != Alen )
12182 {
12183 error( "argument vectors must be same length" ); SWIG_fail;
12184 }
12185 Xlen = Alen;
12186 temp23 = args(18).matrix_value();
12187 arg23 = new PLINT[Alen];
12188 _cvt_double_to( arg23, &temp23( 0, 0 ), Alen );
12189 Ylen = -1;
12190 for ( i = 0; i < Xlen; i++ )
12191 if ( arg23[i] > Ylen )
12192 Ylen = arg23[i];
12193 }
12194 {
12195 if ( _n_dims( args(19) ) > 2 )
12196 {
12197 error( "argument must be a scalar, vector, or 2D matrix." ); SWIG_fail;
12198 }
12199 if ( _dim( args(19), 0 ) != Xlen )
12200 {
12201 error( "argument matrix must have same X length as X vector" ); SWIG_fail;
12202 }
12203 if ( _dim( args(19), 1 ) != Ylen )
12204 {
12205 error( "argument matrix must have same Y length as Y vector" ); SWIG_fail;
12206 }
12207 temp24 = args(19).matrix_value();
12208 arg24 = &temp24( 0, 0 );
12209 }
12210 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);
12211 _outv = octave_value();
12212 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12213 if (SWIG_IsTmpObj(res1)) {
12214 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
12215 } else {
12216 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12217 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
12218 }
12219 if (SWIG_IsTmpObj(res2)) {
12220 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
12221 } else {
12222 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12223 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
12224 }
12225 {
12226 delete [] arg17;
12227 }
12228 {
12229 int i;
12230 if ( arg18 != NULL )
12231 {
12232 for ( i = 0; i < Alen; i++ )
12233 {
12234 delete[] arg18[i];
12235 }
12236 delete[] arg18;
12237 }
12238 }
12239 {
12240 int i;
12241 if ( arg20 != NULL )
12242 {
12243 for ( i = 0; i < Alen; i++ )
12244 {
12245 delete[] arg20[i];
12246 }
12247 delete[] arg20;
12248 }
12249 }
12250 {
12251
12252 }
12253 {
12254 delete [] arg22;
12255 }
12256 {
12257 delete [] arg23;
12258 }
12259 {
12260
12261 }
12262 fail:
12263 return _out;
12264 }
12265
12266
12267 SWIG_DEFUN( PLGraphicsIn_type_set, _wrap_PLGraphicsIn_type_set, std::string() ) {
12268 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12269 int arg2 ;
12270 void *argp1 = 0 ;
12271 int res1 = 0 ;
12272 int val2 ;
12273 int ecode2 = 0 ;
12274 octave_value_list _out;
12275 octave_value_list *_outp=&_out;
12276 octave_value _outv;
12277
12278 if (!SWIG_check_num_args("PLGraphicsIn_type_set",args.length(),2,2,0)) {
12279 SWIG_fail;
12280 }
12281 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12282 if (!SWIG_IsOK(res1)) {
12283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12284 }
12285 arg1 = (PLGraphicsIn *)(argp1);
12286 ecode2 = SWIG_AsVal_int(args(1), &val2);
12287 if (!SWIG_IsOK(ecode2)) {
12288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_type_set" "', argument " "2"" of type '" "int""'");
12289 }
12290 arg2 = (int)(val2);
12291 if (arg1) (arg1)->type = arg2;
12292 _outv = octave_value();
12293 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12294 fail:
12295 return _out;
12296 }
12297
12298
12299 SWIG_DEFUN( PLGraphicsIn_type_get, _wrap_PLGraphicsIn_type_get, std::string() ) {
12300 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12301 void *argp1 = 0 ;
12302 int res1 = 0 ;
12303 octave_value_list _out;
12304 octave_value_list *_outp=&_out;
12305 octave_value _outv;
12306 int result;
12307
12308 if (!SWIG_check_num_args("PLGraphicsIn_type_get",args.length(),1,1,0)) {
12309 SWIG_fail;
12310 }
12311 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12312 if (!SWIG_IsOK(res1)) {
12313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_type_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12314 }
12315 arg1 = (PLGraphicsIn *)(argp1);
12316 result = (int) ((arg1)->type);
12317 _outv = SWIG_From_int((int)(result));
12318 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12319 fail:
12320 return _out;
12321 }
12322
12323
12324 SWIG_DEFUN( PLGraphicsIn_state_set, _wrap_PLGraphicsIn_state_set, std::string() ) {
12325 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12326 unsigned int arg2 ;
12327 void *argp1 = 0 ;
12328 int res1 = 0 ;
12329 unsigned int val2 ;
12330 int ecode2 = 0 ;
12331 octave_value_list _out;
12332 octave_value_list *_outp=&_out;
12333 octave_value _outv;
12334
12335 if (!SWIG_check_num_args("PLGraphicsIn_state_set",args.length(),2,2,0)) {
12336 SWIG_fail;
12337 }
12338 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12339 if (!SWIG_IsOK(res1)) {
12340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12341 }
12342 arg1 = (PLGraphicsIn *)(argp1);
12343 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
12344 if (!SWIG_IsOK(ecode2)) {
12345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_state_set" "', argument " "2"" of type '" "unsigned int""'");
12346 }
12347 arg2 = (unsigned int)(val2);
12348 if (arg1) (arg1)->state = arg2;
12349 _outv = octave_value();
12350 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12351 fail:
12352 return _out;
12353 }
12354
12355
12356 SWIG_DEFUN( PLGraphicsIn_state_get, _wrap_PLGraphicsIn_state_get, std::string() ) {
12357 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12358 void *argp1 = 0 ;
12359 int res1 = 0 ;
12360 octave_value_list _out;
12361 octave_value_list *_outp=&_out;
12362 octave_value _outv;
12363 unsigned int result;
12364
12365 if (!SWIG_check_num_args("PLGraphicsIn_state_get",args.length(),1,1,0)) {
12366 SWIG_fail;
12367 }
12368 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12369 if (!SWIG_IsOK(res1)) {
12370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_state_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12371 }
12372 arg1 = (PLGraphicsIn *)(argp1);
12373 result = (unsigned int) ((arg1)->state);
12374 _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
12375 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12376 fail:
12377 return _out;
12378 }
12379
12380
12381 SWIG_DEFUN( PLGraphicsIn_keysym_set, _wrap_PLGraphicsIn_keysym_set, std::string() ) {
12382 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12383 unsigned int arg2 ;
12384 void *argp1 = 0 ;
12385 int res1 = 0 ;
12386 unsigned int val2 ;
12387 int ecode2 = 0 ;
12388 octave_value_list _out;
12389 octave_value_list *_outp=&_out;
12390 octave_value _outv;
12391
12392 if (!SWIG_check_num_args("PLGraphicsIn_keysym_set",args.length(),2,2,0)) {
12393 SWIG_fail;
12394 }
12395 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12396 if (!SWIG_IsOK(res1)) {
12397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12398 }
12399 arg1 = (PLGraphicsIn *)(argp1);
12400 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
12401 if (!SWIG_IsOK(ecode2)) {
12402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_keysym_set" "', argument " "2"" of type '" "unsigned int""'");
12403 }
12404 arg2 = (unsigned int)(val2);
12405 if (arg1) (arg1)->keysym = arg2;
12406 _outv = octave_value();
12407 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12408 fail:
12409 return _out;
12410 }
12411
12412
12413 SWIG_DEFUN( PLGraphicsIn_keysym_get, _wrap_PLGraphicsIn_keysym_get, std::string() ) {
12414 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12415 void *argp1 = 0 ;
12416 int res1 = 0 ;
12417 octave_value_list _out;
12418 octave_value_list *_outp=&_out;
12419 octave_value _outv;
12420 unsigned int result;
12421
12422 if (!SWIG_check_num_args("PLGraphicsIn_keysym_get",args.length(),1,1,0)) {
12423 SWIG_fail;
12424 }
12425 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12426 if (!SWIG_IsOK(res1)) {
12427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_keysym_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12428 }
12429 arg1 = (PLGraphicsIn *)(argp1);
12430 result = (unsigned int) ((arg1)->keysym);
12431 _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
12432 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12433 fail:
12434 return _out;
12435 }
12436
12437
12438 SWIG_DEFUN( PLGraphicsIn_button_set, _wrap_PLGraphicsIn_button_set, std::string() ) {
12439 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12440 unsigned int arg2 ;
12441 void *argp1 = 0 ;
12442 int res1 = 0 ;
12443 unsigned int val2 ;
12444 int ecode2 = 0 ;
12445 octave_value_list _out;
12446 octave_value_list *_outp=&_out;
12447 octave_value _outv;
12448
12449 if (!SWIG_check_num_args("PLGraphicsIn_button_set",args.length(),2,2,0)) {
12450 SWIG_fail;
12451 }
12452 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12453 if (!SWIG_IsOK(res1)) {
12454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12455 }
12456 arg1 = (PLGraphicsIn *)(argp1);
12457 ecode2 = SWIG_AsVal_unsigned_SS_int(args(1), &val2);
12458 if (!SWIG_IsOK(ecode2)) {
12459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_button_set" "', argument " "2"" of type '" "unsigned int""'");
12460 }
12461 arg2 = (unsigned int)(val2);
12462 if (arg1) (arg1)->button = arg2;
12463 _outv = octave_value();
12464 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12465 fail:
12466 return _out;
12467 }
12468
12469
12470 SWIG_DEFUN( PLGraphicsIn_button_get, _wrap_PLGraphicsIn_button_get, std::string() ) {
12471 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12472 void *argp1 = 0 ;
12473 int res1 = 0 ;
12474 octave_value_list _out;
12475 octave_value_list *_outp=&_out;
12476 octave_value _outv;
12477 unsigned int result;
12478
12479 if (!SWIG_check_num_args("PLGraphicsIn_button_get",args.length(),1,1,0)) {
12480 SWIG_fail;
12481 }
12482 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12483 if (!SWIG_IsOK(res1)) {
12484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_button_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12485 }
12486 arg1 = (PLGraphicsIn *)(argp1);
12487 result = (unsigned int) ((arg1)->button);
12488 _outv = SWIG_From_unsigned_SS_int((unsigned int)(result));
12489 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12490 fail:
12491 return _out;
12492 }
12493
12494
12495 SWIG_DEFUN( PLGraphicsIn_subwindow_set, _wrap_PLGraphicsIn_subwindow_set, std::string() ) {
12496 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12497 PLINT arg2 ;
12498 void *argp1 = 0 ;
12499 int res1 = 0 ;
12500 int val2 ;
12501 int ecode2 = 0 ;
12502 octave_value_list _out;
12503 octave_value_list *_outp=&_out;
12504 octave_value _outv;
12505
12506 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_set",args.length(),2,2,0)) {
12507 SWIG_fail;
12508 }
12509 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12510 if (!SWIG_IsOK(res1)) {
12511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12512 }
12513 arg1 = (PLGraphicsIn *)(argp1);
12514 ecode2 = SWIG_AsVal_int(args(1), &val2);
12515 if (!SWIG_IsOK(ecode2)) {
12516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_subwindow_set" "', argument " "2"" of type '" "PLINT""'");
12517 }
12518 arg2 = (PLINT)(val2);
12519 if (arg1) (arg1)->subwindow = arg2;
12520 _outv = octave_value();
12521 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12522 fail:
12523 return _out;
12524 }
12525
12526
12527 SWIG_DEFUN( PLGraphicsIn_subwindow_get, _wrap_PLGraphicsIn_subwindow_get, std::string() ) {
12528 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12529 void *argp1 = 0 ;
12530 int res1 = 0 ;
12531 octave_value_list _out;
12532 octave_value_list *_outp=&_out;
12533 octave_value _outv;
12534 PLINT result;
12535
12536 if (!SWIG_check_num_args("PLGraphicsIn_subwindow_get",args.length(),1,1,0)) {
12537 SWIG_fail;
12538 }
12539 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12540 if (!SWIG_IsOK(res1)) {
12541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_subwindow_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12542 }
12543 arg1 = (PLGraphicsIn *)(argp1);
12544 result = (PLINT) ((arg1)->subwindow);
12545 _outv = SWIG_From_int((int)(result));
12546 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12547 fail:
12548 return _out;
12549 }
12550
12551
12552 SWIG_DEFUN( PLGraphicsIn_string_set, _wrap_PLGraphicsIn_string_set, std::string() ) {
12553 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12554 char *arg2 ;
12555 void *argp1 = 0 ;
12556 int res1 = 0 ;
12557 char temp2[16] ;
12558 int res2 ;
12559 octave_value_list _out;
12560 octave_value_list *_outp=&_out;
12561 octave_value _outv;
12562
12563 if (!SWIG_check_num_args("PLGraphicsIn_string_set",args.length(),2,2,0)) {
12564 SWIG_fail;
12565 }
12566 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12567 if (!SWIG_IsOK(res1)) {
12568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12569 }
12570 arg1 = (PLGraphicsIn *)(argp1);
12571 res2 = SWIG_AsCharArray(args(1), temp2, 16);
12572 if (!SWIG_IsOK(res2)) {
12573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PLGraphicsIn_string_set" "', argument " "2"" of type '" "char [16]""'");
12574 }
12575 arg2 = (char *)(temp2);
12576 if (arg2) memcpy(arg1->string,arg2,16*sizeof(char));
12577 else memset(arg1->string,0,16*sizeof(char));
12578 _outv = octave_value();
12579 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12580 fail:
12581 return _out;
12582 }
12583
12584
12585 SWIG_DEFUN( PLGraphicsIn_string_get, _wrap_PLGraphicsIn_string_get, std::string() ) {
12586 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12587 void *argp1 = 0 ;
12588 int res1 = 0 ;
12589 octave_value_list _out;
12590 octave_value_list *_outp=&_out;
12591 octave_value _outv;
12592 char *result = 0 ;
12593
12594 if (!SWIG_check_num_args("PLGraphicsIn_string_get",args.length(),1,1,0)) {
12595 SWIG_fail;
12596 }
12597 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12598 if (!SWIG_IsOK(res1)) {
12599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_string_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12600 }
12601 arg1 = (PLGraphicsIn *)(argp1);
12602 result = (char *)(char *) ((arg1)->string);
12603 {
12604 size_t size = 16;
12605
12606 while (size && (result[size - 1] == '\0')) --size;
12607
12608 _outv = SWIG_FromCharPtrAndSize(result, size);
12609 }
12610 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12611 fail:
12612 return _out;
12613 }
12614
12615
12616 SWIG_DEFUN( PLGraphicsIn_pX_set, _wrap_PLGraphicsIn_pX_set, std::string() ) {
12617 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12618 int arg2 ;
12619 void *argp1 = 0 ;
12620 int res1 = 0 ;
12621 int val2 ;
12622 int ecode2 = 0 ;
12623 octave_value_list _out;
12624 octave_value_list *_outp=&_out;
12625 octave_value _outv;
12626
12627 if (!SWIG_check_num_args("PLGraphicsIn_pX_set",args.length(),2,2,0)) {
12628 SWIG_fail;
12629 }
12630 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12631 if (!SWIG_IsOK(res1)) {
12632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12633 }
12634 arg1 = (PLGraphicsIn *)(argp1);
12635 ecode2 = SWIG_AsVal_int(args(1), &val2);
12636 if (!SWIG_IsOK(ecode2)) {
12637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pX_set" "', argument " "2"" of type '" "int""'");
12638 }
12639 arg2 = (int)(val2);
12640 if (arg1) (arg1)->pX = arg2;
12641 _outv = octave_value();
12642 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12643 fail:
12644 return _out;
12645 }
12646
12647
12648 SWIG_DEFUN( PLGraphicsIn_pX_get, _wrap_PLGraphicsIn_pX_get, std::string() ) {
12649 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12650 void *argp1 = 0 ;
12651 int res1 = 0 ;
12652 octave_value_list _out;
12653 octave_value_list *_outp=&_out;
12654 octave_value _outv;
12655 int result;
12656
12657 if (!SWIG_check_num_args("PLGraphicsIn_pX_get",args.length(),1,1,0)) {
12658 SWIG_fail;
12659 }
12660 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12661 if (!SWIG_IsOK(res1)) {
12662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12663 }
12664 arg1 = (PLGraphicsIn *)(argp1);
12665 result = (int) ((arg1)->pX);
12666 _outv = SWIG_From_int((int)(result));
12667 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12668 fail:
12669 return _out;
12670 }
12671
12672
12673 SWIG_DEFUN( PLGraphicsIn_pY_set, _wrap_PLGraphicsIn_pY_set, std::string() ) {
12674 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12675 int arg2 ;
12676 void *argp1 = 0 ;
12677 int res1 = 0 ;
12678 int val2 ;
12679 int ecode2 = 0 ;
12680 octave_value_list _out;
12681 octave_value_list *_outp=&_out;
12682 octave_value _outv;
12683
12684 if (!SWIG_check_num_args("PLGraphicsIn_pY_set",args.length(),2,2,0)) {
12685 SWIG_fail;
12686 }
12687 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12688 if (!SWIG_IsOK(res1)) {
12689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12690 }
12691 arg1 = (PLGraphicsIn *)(argp1);
12692 ecode2 = SWIG_AsVal_int(args(1), &val2);
12693 if (!SWIG_IsOK(ecode2)) {
12694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_pY_set" "', argument " "2"" of type '" "int""'");
12695 }
12696 arg2 = (int)(val2);
12697 if (arg1) (arg1)->pY = arg2;
12698 _outv = octave_value();
12699 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12700 fail:
12701 return _out;
12702 }
12703
12704
12705 SWIG_DEFUN( PLGraphicsIn_pY_get, _wrap_PLGraphicsIn_pY_get, std::string() ) {
12706 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12707 void *argp1 = 0 ;
12708 int res1 = 0 ;
12709 octave_value_list _out;
12710 octave_value_list *_outp=&_out;
12711 octave_value _outv;
12712 int result;
12713
12714 if (!SWIG_check_num_args("PLGraphicsIn_pY_get",args.length(),1,1,0)) {
12715 SWIG_fail;
12716 }
12717 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12718 if (!SWIG_IsOK(res1)) {
12719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_pY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12720 }
12721 arg1 = (PLGraphicsIn *)(argp1);
12722 result = (int) ((arg1)->pY);
12723 _outv = SWIG_From_int((int)(result));
12724 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12725 fail:
12726 return _out;
12727 }
12728
12729
12730 SWIG_DEFUN( PLGraphicsIn_dX_set, _wrap_PLGraphicsIn_dX_set, std::string() ) {
12731 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12732 PLFLT arg2 ;
12733 void *argp1 = 0 ;
12734 int res1 = 0 ;
12735 double val2 ;
12736 int ecode2 = 0 ;
12737 octave_value_list _out;
12738 octave_value_list *_outp=&_out;
12739 octave_value _outv;
12740
12741 if (!SWIG_check_num_args("PLGraphicsIn_dX_set",args.length(),2,2,0)) {
12742 SWIG_fail;
12743 }
12744 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12745 if (!SWIG_IsOK(res1)) {
12746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12747 }
12748 arg1 = (PLGraphicsIn *)(argp1);
12749 ecode2 = SWIG_AsVal_double(args(1), &val2);
12750 if (!SWIG_IsOK(ecode2)) {
12751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dX_set" "', argument " "2"" of type '" "PLFLT""'");
12752 }
12753 arg2 = (PLFLT)(val2);
12754 if (arg1) (arg1)->dX = arg2;
12755 _outv = octave_value();
12756 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12757 fail:
12758 return _out;
12759 }
12760
12761
12762 SWIG_DEFUN( PLGraphicsIn_dX_get, _wrap_PLGraphicsIn_dX_get, std::string() ) {
12763 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12764 void *argp1 = 0 ;
12765 int res1 = 0 ;
12766 octave_value_list _out;
12767 octave_value_list *_outp=&_out;
12768 octave_value _outv;
12769 PLFLT result;
12770
12771 if (!SWIG_check_num_args("PLGraphicsIn_dX_get",args.length(),1,1,0)) {
12772 SWIG_fail;
12773 }
12774 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12775 if (!SWIG_IsOK(res1)) {
12776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12777 }
12778 arg1 = (PLGraphicsIn *)(argp1);
12779 result = (PLFLT) ((arg1)->dX);
12780 _outv = SWIG_From_double((double)(result));
12781 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12782 fail:
12783 return _out;
12784 }
12785
12786
12787 SWIG_DEFUN( PLGraphicsIn_dY_set, _wrap_PLGraphicsIn_dY_set, std::string() ) {
12788 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12789 PLFLT arg2 ;
12790 void *argp1 = 0 ;
12791 int res1 = 0 ;
12792 double val2 ;
12793 int ecode2 = 0 ;
12794 octave_value_list _out;
12795 octave_value_list *_outp=&_out;
12796 octave_value _outv;
12797
12798 if (!SWIG_check_num_args("PLGraphicsIn_dY_set",args.length(),2,2,0)) {
12799 SWIG_fail;
12800 }
12801 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12802 if (!SWIG_IsOK(res1)) {
12803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12804 }
12805 arg1 = (PLGraphicsIn *)(argp1);
12806 ecode2 = SWIG_AsVal_double(args(1), &val2);
12807 if (!SWIG_IsOK(ecode2)) {
12808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_dY_set" "', argument " "2"" of type '" "PLFLT""'");
12809 }
12810 arg2 = (PLFLT)(val2);
12811 if (arg1) (arg1)->dY = arg2;
12812 _outv = octave_value();
12813 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12814 fail:
12815 return _out;
12816 }
12817
12818
12819 SWIG_DEFUN( PLGraphicsIn_dY_get, _wrap_PLGraphicsIn_dY_get, std::string() ) {
12820 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12821 void *argp1 = 0 ;
12822 int res1 = 0 ;
12823 octave_value_list _out;
12824 octave_value_list *_outp=&_out;
12825 octave_value _outv;
12826 PLFLT result;
12827
12828 if (!SWIG_check_num_args("PLGraphicsIn_dY_get",args.length(),1,1,0)) {
12829 SWIG_fail;
12830 }
12831 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12832 if (!SWIG_IsOK(res1)) {
12833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_dY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12834 }
12835 arg1 = (PLGraphicsIn *)(argp1);
12836 result = (PLFLT) ((arg1)->dY);
12837 _outv = SWIG_From_double((double)(result));
12838 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12839 fail:
12840 return _out;
12841 }
12842
12843
12844 SWIG_DEFUN( PLGraphicsIn_wX_set, _wrap_PLGraphicsIn_wX_set, std::string() ) {
12845 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12846 PLFLT arg2 ;
12847 void *argp1 = 0 ;
12848 int res1 = 0 ;
12849 double val2 ;
12850 int ecode2 = 0 ;
12851 octave_value_list _out;
12852 octave_value_list *_outp=&_out;
12853 octave_value _outv;
12854
12855 if (!SWIG_check_num_args("PLGraphicsIn_wX_set",args.length(),2,2,0)) {
12856 SWIG_fail;
12857 }
12858 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12859 if (!SWIG_IsOK(res1)) {
12860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12861 }
12862 arg1 = (PLGraphicsIn *)(argp1);
12863 ecode2 = SWIG_AsVal_double(args(1), &val2);
12864 if (!SWIG_IsOK(ecode2)) {
12865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wX_set" "', argument " "2"" of type '" "PLFLT""'");
12866 }
12867 arg2 = (PLFLT)(val2);
12868 if (arg1) (arg1)->wX = arg2;
12869 _outv = octave_value();
12870 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12871 fail:
12872 return _out;
12873 }
12874
12875
12876 SWIG_DEFUN( PLGraphicsIn_wX_get, _wrap_PLGraphicsIn_wX_get, std::string() ) {
12877 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12878 void *argp1 = 0 ;
12879 int res1 = 0 ;
12880 octave_value_list _out;
12881 octave_value_list *_outp=&_out;
12882 octave_value _outv;
12883 PLFLT result;
12884
12885 if (!SWIG_check_num_args("PLGraphicsIn_wX_get",args.length(),1,1,0)) {
12886 SWIG_fail;
12887 }
12888 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12889 if (!SWIG_IsOK(res1)) {
12890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wX_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12891 }
12892 arg1 = (PLGraphicsIn *)(argp1);
12893 result = (PLFLT) ((arg1)->wX);
12894 _outv = SWIG_From_double((double)(result));
12895 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12896 fail:
12897 return _out;
12898 }
12899
12900
12901 SWIG_DEFUN( PLGraphicsIn_wY_set, _wrap_PLGraphicsIn_wY_set, std::string() ) {
12902 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12903 PLFLT arg2 ;
12904 void *argp1 = 0 ;
12905 int res1 = 0 ;
12906 double val2 ;
12907 int ecode2 = 0 ;
12908 octave_value_list _out;
12909 octave_value_list *_outp=&_out;
12910 octave_value _outv;
12911
12912 if (!SWIG_check_num_args("PLGraphicsIn_wY_set",args.length(),2,2,0)) {
12913 SWIG_fail;
12914 }
12915 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12916 if (!SWIG_IsOK(res1)) {
12917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_set" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12918 }
12919 arg1 = (PLGraphicsIn *)(argp1);
12920 ecode2 = SWIG_AsVal_double(args(1), &val2);
12921 if (!SWIG_IsOK(ecode2)) {
12922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PLGraphicsIn_wY_set" "', argument " "2"" of type '" "PLFLT""'");
12923 }
12924 arg2 = (PLFLT)(val2);
12925 if (arg1) (arg1)->wY = arg2;
12926 _outv = octave_value();
12927 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12928 fail:
12929 return _out;
12930 }
12931
12932
12933 SWIG_DEFUN( PLGraphicsIn_wY_get, _wrap_PLGraphicsIn_wY_get, std::string() ) {
12934 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12935 void *argp1 = 0 ;
12936 int res1 = 0 ;
12937 octave_value_list _out;
12938 octave_value_list *_outp=&_out;
12939 octave_value _outv;
12940 PLFLT result;
12941
12942 if (!SWIG_check_num_args("PLGraphicsIn_wY_get",args.length(),1,1,0)) {
12943 SWIG_fail;
12944 }
12945 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, 0 | 0 );
12946 if (!SWIG_IsOK(res1)) {
12947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PLGraphicsIn_wY_get" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12948 }
12949 arg1 = (PLGraphicsIn *)(argp1);
12950 result = (PLFLT) ((arg1)->wY);
12951 _outv = SWIG_From_double((double)(result));
12952 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12953 fail:
12954 return _out;
12955 }
12956
12957
12958 SWIG_DEFUN( new_PLGraphicsIn, _wrap_new_PLGraphicsIn, std::string() ) {
12959 octave_value_list _out;
12960 octave_value_list *_outp=&_out;
12961 octave_value _outv;
12962 PLGraphicsIn *result = 0 ;
12963
12964 if (!SWIG_check_num_args("new_PLGraphicsIn",args.length(),0,0,0)) {
12965 SWIG_fail;
12966 }
12967 result = (PLGraphicsIn *)new PLGraphicsIn();
12968 _outv = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PLGraphicsIn, 1 | 0 );
12969 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12970 fail:
12971 return _out;
12972 }
12973
12974
12975 SWIG_DEFUN( delete_PLGraphicsIn, _wrap_delete_PLGraphicsIn, std::string() ) {
12976 PLGraphicsIn *arg1 = (PLGraphicsIn *) 0 ;
12977 void *argp1 = 0 ;
12978 int res1 = 0 ;
12979 octave_value_list _out;
12980 octave_value_list *_outp=&_out;
12981 octave_value _outv;
12982
12983 if (!SWIG_check_num_args("delete_PLGraphicsIn",args.length(),1,1,0)) {
12984 SWIG_fail;
12985 }
12986 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_PLGraphicsIn, SWIG_POINTER_DISOWN | 0 );
12987 if (!SWIG_IsOK(res1)) {
12988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PLGraphicsIn" "', argument " "1"" of type '" "PLGraphicsIn *""'");
12989 }
12990 arg1 = (PLGraphicsIn *)(argp1);
12991 delete arg1;
12992 _outv = octave_value();
12993 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
12994 fail:
12995 return _out;
12996 }
12997
12998
12999 static swig_octave_member swig_PLGraphicsIn_members[] = {
13000 {"type",0,_wrap_PLGraphicsIn_type_get,_wrap_PLGraphicsIn_type_set,0,0},
13001 {"state",0,_wrap_PLGraphicsIn_state_get,_wrap_PLGraphicsIn_state_set,0,0},
13002 {"keysym",0,_wrap_PLGraphicsIn_keysym_get,_wrap_PLGraphicsIn_keysym_set,0,0},
13003 {"button",0,_wrap_PLGraphicsIn_button_get,_wrap_PLGraphicsIn_button_set,0,0},
13004 {"subwindow",0,_wrap_PLGraphicsIn_subwindow_get,_wrap_PLGraphicsIn_subwindow_set,0,0},
13005 {"string",0,_wrap_PLGraphicsIn_string_get,_wrap_PLGraphicsIn_string_set,0,0},
13006 {"pX",0,_wrap_PLGraphicsIn_pX_get,_wrap_PLGraphicsIn_pX_set,0,0},
13007 {"pY",0,_wrap_PLGraphicsIn_pY_get,_wrap_PLGraphicsIn_pY_set,0,0},
13008 {"dX",0,_wrap_PLGraphicsIn_dX_get,_wrap_PLGraphicsIn_dX_set,0,0},
13009 {"dY",0,_wrap_PLGraphicsIn_dY_get,_wrap_PLGraphicsIn_dY_set,0,0},
13010 {"wX",0,_wrap_PLGraphicsIn_wX_get,_wrap_PLGraphicsIn_wX_set,0,0},
13011 {"wY",0,_wrap_PLGraphicsIn_wY_get,_wrap_PLGraphicsIn_wY_set,0,0},
13012 {0,0,0,0}
13013 };
13014 static const char *swig_PLGraphicsIn_base_names[] = {0};
13015 static const swig_type_info *swig_PLGraphicsIn_base[] = {0};
13016 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 };
13017
13018 SWIG_DEFUN( pl_setcontlabelformat, _wrap_pl_setcontlabelformat, _wrap_pl_setcontlabelformat_texinfo ) {
13019 PLINT arg1 ;
13020 PLINT arg2 ;
13021 int val1 ;
13022 int ecode1 = 0 ;
13023 int val2 ;
13024 int ecode2 = 0 ;
13025 octave_value_list _out;
13026 octave_value_list *_outp=&_out;
13027 octave_value _outv;
13028
13029 if (!SWIG_check_num_args("pl_setcontlabelformat",args.length(),2,2,0)) {
13030 SWIG_fail;
13031 }
13032 ecode1 = SWIG_AsVal_int(args(0), &val1);
13033 if (!SWIG_IsOK(ecode1)) {
13034 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelformat" "', argument " "1"" of type '" "PLINT""'");
13035 }
13036 arg1 = (PLINT)(val1);
13037 ecode2 = SWIG_AsVal_int(args(1), &val2);
13038 if (!SWIG_IsOK(ecode2)) {
13039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelformat" "', argument " "2"" of type '" "PLINT""'");
13040 }
13041 arg2 = (PLINT)(val2);
13042 pl_setcontlabelformat(arg1,arg2);
13043 _outv = octave_value();
13044 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13045 fail:
13046 return _out;
13047 }
13048
13049
13050 SWIG_DEFUN( pl_setcontlabelparam, _wrap_pl_setcontlabelparam, _wrap_pl_setcontlabelparam_texinfo ) {
13051 PLFLT arg1 ;
13052 PLFLT arg2 ;
13053 PLFLT arg3 ;
13054 PLINT arg4 ;
13055 double val1 ;
13056 int ecode1 = 0 ;
13057 double val2 ;
13058 int ecode2 = 0 ;
13059 double val3 ;
13060 int ecode3 = 0 ;
13061 int val4 ;
13062 int ecode4 = 0 ;
13063 octave_value_list _out;
13064 octave_value_list *_outp=&_out;
13065 octave_value _outv;
13066
13067 if (!SWIG_check_num_args("pl_setcontlabelparam",args.length(),4,4,0)) {
13068 SWIG_fail;
13069 }
13070 ecode1 = SWIG_AsVal_double(args(0), &val1);
13071 if (!SWIG_IsOK(ecode1)) {
13072 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pl_setcontlabelparam" "', argument " "1"" of type '" "PLFLT""'");
13073 }
13074 arg1 = (PLFLT)(val1);
13075 ecode2 = SWIG_AsVal_double(args(1), &val2);
13076 if (!SWIG_IsOK(ecode2)) {
13077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pl_setcontlabelparam" "', argument " "2"" of type '" "PLFLT""'");
13078 }
13079 arg2 = (PLFLT)(val2);
13080 ecode3 = SWIG_AsVal_double(args(2), &val3);
13081 if (!SWIG_IsOK(ecode3)) {
13082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pl_setcontlabelparam" "', argument " "3"" of type '" "PLFLT""'");
13083 }
13084 arg3 = (PLFLT)(val3);
13085 ecode4 = SWIG_AsVal_int(args(3), &val4);
13086 if (!SWIG_IsOK(ecode4)) {
13087 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pl_setcontlabelparam" "', argument " "4"" of type '" "PLINT""'");
13088 }
13089 arg4 = (PLINT)(val4);
13090 pl_setcontlabelparam(arg1,arg2,arg3,arg4);
13091 _outv = octave_value();
13092 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13093 fail:
13094 return _out;
13095 }
13096
13097
13098 SWIG_DEFUN( pladv, _wrap_pladv, _wrap_pladv_texinfo ) {
13099 PLINT arg1 ;
13100 int val1 ;
13101 int ecode1 = 0 ;
13102 octave_value_list _out;
13103 octave_value_list *_outp=&_out;
13104 octave_value _outv;
13105
13106 if (!SWIG_check_num_args("pladv",args.length(),1,1,0)) {
13107 SWIG_fail;
13108 }
13109 ecode1 = SWIG_AsVal_int(args(0), &val1);
13110 if (!SWIG_IsOK(ecode1)) {
13111 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pladv" "', argument " "1"" of type '" "PLINT""'");
13112 }
13113 arg1 = (PLINT)(val1);
13114 pladv(arg1);
13115 _outv = octave_value();
13116 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13117 fail:
13118 return _out;
13119 }
13120
13121
13122 SWIG_DEFUN( plarc, _wrap_plarc, _wrap_plarc_texinfo ) {
13123 PLFLT arg1 ;
13124 PLFLT arg2 ;
13125 PLFLT arg3 ;
13126 PLFLT arg4 ;
13127 PLFLT arg5 ;
13128 PLFLT arg6 ;
13129 PLFLT arg7 ;
13130 PLBOOL arg8 ;
13131 double val1 ;
13132 int ecode1 = 0 ;
13133 double val2 ;
13134 int ecode2 = 0 ;
13135 double val3 ;
13136 int ecode3 = 0 ;
13137 double val4 ;
13138 int ecode4 = 0 ;
13139 double val5 ;
13140 int ecode5 = 0 ;
13141 double val6 ;
13142 int ecode6 = 0 ;
13143 double val7 ;
13144 int ecode7 = 0 ;
13145 int val8 ;
13146 int ecode8 = 0 ;
13147 octave_value_list _out;
13148 octave_value_list *_outp=&_out;
13149 octave_value _outv;
13150
13151 if (!SWIG_check_num_args("plarc",args.length(),8,8,0)) {
13152 SWIG_fail;
13153 }
13154 ecode1 = SWIG_AsVal_double(args(0), &val1);
13155 if (!SWIG_IsOK(ecode1)) {
13156 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plarc" "', argument " "1"" of type '" "PLFLT""'");
13157 }
13158 arg1 = (PLFLT)(val1);
13159 ecode2 = SWIG_AsVal_double(args(1), &val2);
13160 if (!SWIG_IsOK(ecode2)) {
13161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plarc" "', argument " "2"" of type '" "PLFLT""'");
13162 }
13163 arg2 = (PLFLT)(val2);
13164 ecode3 = SWIG_AsVal_double(args(2), &val3);
13165 if (!SWIG_IsOK(ecode3)) {
13166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plarc" "', argument " "3"" of type '" "PLFLT""'");
13167 }
13168 arg3 = (PLFLT)(val3);
13169 ecode4 = SWIG_AsVal_double(args(3), &val4);
13170 if (!SWIG_IsOK(ecode4)) {
13171 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plarc" "', argument " "4"" of type '" "PLFLT""'");
13172 }
13173 arg4 = (PLFLT)(val4);
13174 ecode5 = SWIG_AsVal_double(args(4), &val5);
13175 if (!SWIG_IsOK(ecode5)) {
13176 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plarc" "', argument " "5"" of type '" "PLFLT""'");
13177 }
13178 arg5 = (PLFLT)(val5);
13179 ecode6 = SWIG_AsVal_double(args(5), &val6);
13180 if (!SWIG_IsOK(ecode6)) {
13181 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plarc" "', argument " "6"" of type '" "PLFLT""'");
13182 }
13183 arg6 = (PLFLT)(val6);
13184 ecode7 = SWIG_AsVal_double(args(6), &val7);
13185 if (!SWIG_IsOK(ecode7)) {
13186 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plarc" "', argument " "7"" of type '" "PLFLT""'");
13187 }
13188 arg7 = (PLFLT)(val7);
13189 ecode8 = SWIG_AsVal_int(args(7), &val8);
13190 if (!SWIG_IsOK(ecode8)) {
13191 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plarc" "', argument " "8"" of type '" "PLBOOL""'");
13192 }
13193 arg8 = (PLBOOL)(val8);
13194 plarc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
13195 _outv = octave_value();
13196 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13197 fail:
13198 return _out;
13199 }
13200
13201
13202 SWIG_DEFUN( plaxes, _wrap_plaxes, _wrap_plaxes_texinfo ) {
13203 PLFLT arg1 ;
13204 PLFLT arg2 ;
13205 char *arg3 = (char *) 0 ;
13206 PLFLT arg4 ;
13207 PLINT arg5 ;
13208 char *arg6 = (char *) 0 ;
13209 PLFLT arg7 ;
13210 PLINT arg8 ;
13211 double val1 ;
13212 int ecode1 = 0 ;
13213 double val2 ;
13214 int ecode2 = 0 ;
13215 int res3 ;
13216 char *buf3 = 0 ;
13217 int alloc3 = 0 ;
13218 double val4 ;
13219 int ecode4 = 0 ;
13220 int val5 ;
13221 int ecode5 = 0 ;
13222 int res6 ;
13223 char *buf6 = 0 ;
13224 int alloc6 = 0 ;
13225 double val7 ;
13226 int ecode7 = 0 ;
13227 int val8 ;
13228 int ecode8 = 0 ;
13229 octave_value_list _out;
13230 octave_value_list *_outp=&_out;
13231 octave_value _outv;
13232
13233 if (!SWIG_check_num_args("plaxes",args.length(),8,8,0)) {
13234 SWIG_fail;
13235 }
13236 ecode1 = SWIG_AsVal_double(args(0), &val1);
13237 if (!SWIG_IsOK(ecode1)) {
13238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plaxes" "', argument " "1"" of type '" "PLFLT""'");
13239 }
13240 arg1 = (PLFLT)(val1);
13241 ecode2 = SWIG_AsVal_double(args(1), &val2);
13242 if (!SWIG_IsOK(ecode2)) {
13243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plaxes" "', argument " "2"" of type '" "PLFLT""'");
13244 }
13245 arg2 = (PLFLT)(val2);
13246 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
13247 if (!SWIG_IsOK(res3)) {
13248 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "plaxes" "', argument " "3"" of type '" "char const *""'");
13249 }
13250 arg3 = (char *)(buf3);
13251 ecode4 = SWIG_AsVal_double(args(3), &val4);
13252 if (!SWIG_IsOK(ecode4)) {
13253 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plaxes" "', argument " "4"" of type '" "PLFLT""'");
13254 }
13255 arg4 = (PLFLT)(val4);
13256 ecode5 = SWIG_AsVal_int(args(4), &val5);
13257 if (!SWIG_IsOK(ecode5)) {
13258 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plaxes" "', argument " "5"" of type '" "PLINT""'");
13259 }
13260 arg5 = (PLINT)(val5);
13261 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
13262 if (!SWIG_IsOK(res6)) {
13263 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plaxes" "', argument " "6"" of type '" "char const *""'");
13264 }
13265 arg6 = (char *)(buf6);
13266 ecode7 = SWIG_AsVal_double(args(6), &val7);
13267 if (!SWIG_IsOK(ecode7)) {
13268 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plaxes" "', argument " "7"" of type '" "PLFLT""'");
13269 }
13270 arg7 = (PLFLT)(val7);
13271 ecode8 = SWIG_AsVal_int(args(7), &val8);
13272 if (!SWIG_IsOK(ecode8)) {
13273 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plaxes" "', argument " "8"" of type '" "PLINT""'");
13274 }
13275 arg8 = (PLINT)(val8);
13276 plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
13277 _outv = octave_value();
13278 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13279 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
13280 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
13281 fail:
13282 return _out;
13283 }
13284
13285
13286 SWIG_DEFUN( plbin, _wrap_plbin, _wrap_plbin_texinfo ) {
13287 PLINT arg1 ;
13288 PLFLT *arg2 = (PLFLT *) 0 ;
13289 PLFLT *arg3 = (PLFLT *) 0 ;
13290 PLINT arg4 ;
13291 Matrix temp1 ;
13292 Matrix temp3 ;
13293 int val4 ;
13294 int ecode4 = 0 ;
13295 octave_value_list _out;
13296 octave_value_list *_outp=&_out;
13297 octave_value _outv;
13298
13299 if (!SWIG_check_num_args("plbin",args.length(),3,3,0)) {
13300 SWIG_fail;
13301 }
13302 {
13303 if ( _n_dims( args(0) ) > 1 )
13304 {
13305 error( "argument must be a scalar or vector" ); SWIG_fail;
13306 }
13307 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
13308 temp1 = args(0).matrix_value();
13309 arg2 = &temp1( 0, 0 );
13310 }
13311 {
13312 if ( _n_dims( args(1) ) > 1 )
13313 {
13314 error( "argument must be a scalar or vector" ); SWIG_fail;
13315 }
13316 if ( _dim( args(1), 0 ) != Alen )
13317 {
13318 error( "argument vectors must be same length" ); SWIG_fail;
13319 }
13320 temp3 = args(1).matrix_value();
13321 arg3 = &temp3( 0, 0 );
13322 }
13323 ecode4 = SWIG_AsVal_int(args(2), &val4);
13324 if (!SWIG_IsOK(ecode4)) {
13325 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbin" "', argument " "4"" of type '" "PLINT""'");
13326 }
13327 arg4 = (PLINT)(val4);
13328 plbin(arg1,(double const *)arg2,(double const *)arg3,arg4);
13329 _outv = octave_value();
13330 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13331 {
13332
13333 }
13334 {
13335
13336 }
13337 fail:
13338 return _out;
13339 }
13340
13341
13342 SWIG_DEFUN( plbtime, _wrap_plbtime, std::string() ) {
13343 PLINT *arg1 = (PLINT *) 0 ;
13344 PLINT *arg2 = (PLINT *) 0 ;
13345 PLINT *arg3 = (PLINT *) 0 ;
13346 PLINT *arg4 = (PLINT *) 0 ;
13347 PLINT *arg5 = (PLINT *) 0 ;
13348 PLFLT *arg6 = (PLFLT *) 0 ;
13349 PLFLT arg7 ;
13350 PLINT temp1 ;
13351 int res1 = SWIG_TMPOBJ ;
13352 PLINT temp2 ;
13353 int res2 = SWIG_TMPOBJ ;
13354 PLINT temp3 ;
13355 int res3 = SWIG_TMPOBJ ;
13356 PLINT temp4 ;
13357 int res4 = SWIG_TMPOBJ ;
13358 PLINT temp5 ;
13359 int res5 = SWIG_TMPOBJ ;
13360 PLFLT temp6 ;
13361 int res6 = SWIG_TMPOBJ ;
13362 double val7 ;
13363 int ecode7 = 0 ;
13364 octave_value_list _out;
13365 octave_value_list *_outp=&_out;
13366 octave_value _outv;
13367
13368 arg1 = &temp1;
13369 arg2 = &temp2;
13370 arg3 = &temp3;
13371 arg4 = &temp4;
13372 arg5 = &temp5;
13373 arg6 = &temp6;
13374 if (!SWIG_check_num_args("plbtime",args.length(),1,1,0)) {
13375 SWIG_fail;
13376 }
13377 ecode7 = SWIG_AsVal_double(args(0), &val7);
13378 if (!SWIG_IsOK(ecode7)) {
13379 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbtime" "', argument " "7"" of type '" "PLFLT""'");
13380 }
13381 arg7 = (PLFLT)(val7);
13382 plbtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13383 _outv = octave_value();
13384 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13385 if (SWIG_IsTmpObj(res1)) {
13386 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
13387 } else {
13388 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13389 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
13390 }
13391 if (SWIG_IsTmpObj(res2)) {
13392 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
13393 } else {
13394 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13395 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
13396 }
13397 if (SWIG_IsTmpObj(res3)) {
13398 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
13399 } else {
13400 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13401 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
13402 }
13403 if (SWIG_IsTmpObj(res4)) {
13404 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
13405 } else {
13406 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13407 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
13408 }
13409 if (SWIG_IsTmpObj(res5)) {
13410 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
13411 } else {
13412 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13413 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
13414 }
13415 if (SWIG_IsTmpObj(res6)) {
13416 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
13417 } else {
13418 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13419 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
13420 }
13421 fail:
13422 return _out;
13423 }
13424
13425
13426 SWIG_DEFUN( plbop, _wrap_plbop, _wrap_plbop_texinfo ) {
13427 octave_value_list _out;
13428 octave_value_list *_outp=&_out;
13429 octave_value _outv;
13430
13431 if (!SWIG_check_num_args("plbop",args.length(),0,0,0)) {
13432 SWIG_fail;
13433 }
13434 plbop();
13435 _outv = octave_value();
13436 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13437 fail:
13438 return _out;
13439 }
13440
13441
13442 SWIG_DEFUN( plbox, _wrap_plbox, _wrap_plbox_texinfo ) {
13443 char *arg1 = (char *) 0 ;
13444 PLFLT arg2 ;
13445 PLINT arg3 ;
13446 char *arg4 = (char *) 0 ;
13447 PLFLT arg5 ;
13448 PLINT arg6 ;
13449 int res1 ;
13450 char *buf1 = 0 ;
13451 int alloc1 = 0 ;
13452 double val2 ;
13453 int ecode2 = 0 ;
13454 int val3 ;
13455 int ecode3 = 0 ;
13456 int res4 ;
13457 char *buf4 = 0 ;
13458 int alloc4 = 0 ;
13459 double val5 ;
13460 int ecode5 = 0 ;
13461 int val6 ;
13462 int ecode6 = 0 ;
13463 octave_value_list _out;
13464 octave_value_list *_outp=&_out;
13465 octave_value _outv;
13466
13467 if (!SWIG_check_num_args("plbox",args.length(),6,6,0)) {
13468 SWIG_fail;
13469 }
13470 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
13471 if (!SWIG_IsOK(res1)) {
13472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox" "', argument " "1"" of type '" "char const *""'");
13473 }
13474 arg1 = (char *)(buf1);
13475 ecode2 = SWIG_AsVal_double(args(1), &val2);
13476 if (!SWIG_IsOK(ecode2)) {
13477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plbox" "', argument " "2"" of type '" "PLFLT""'");
13478 }
13479 arg2 = (PLFLT)(val2);
13480 ecode3 = SWIG_AsVal_int(args(2), &val3);
13481 if (!SWIG_IsOK(ecode3)) {
13482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox" "', argument " "3"" of type '" "PLINT""'");
13483 }
13484 arg3 = (PLINT)(val3);
13485 res4 = SWIG_AsCharPtrAndSize(args(3), &buf4, NULL, &alloc4);
13486 if (!SWIG_IsOK(res4)) {
13487 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plbox" "', argument " "4"" of type '" "char const *""'");
13488 }
13489 arg4 = (char *)(buf4);
13490 ecode5 = SWIG_AsVal_double(args(4), &val5);
13491 if (!SWIG_IsOK(ecode5)) {
13492 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plbox" "', argument " "5"" of type '" "PLFLT""'");
13493 }
13494 arg5 = (PLFLT)(val5);
13495 ecode6 = SWIG_AsVal_int(args(5), &val6);
13496 if (!SWIG_IsOK(ecode6)) {
13497 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plbox" "', argument " "6"" of type '" "PLINT""'");
13498 }
13499 arg6 = (PLINT)(val6);
13500 plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
13501 _outv = octave_value();
13502 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13503 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13504 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
13505 fail:
13506 return _out;
13507 }
13508
13509
13510 SWIG_DEFUN( plbox3, _wrap_plbox3, _wrap_plbox3_texinfo ) {
13511 char *arg1 = (char *) 0 ;
13512 char *arg2 = (char *) 0 ;
13513 PLFLT arg3 ;
13514 PLINT arg4 ;
13515 char *arg5 = (char *) 0 ;
13516 char *arg6 = (char *) 0 ;
13517 PLFLT arg7 ;
13518 PLINT arg8 ;
13519 char *arg9 = (char *) 0 ;
13520 char *arg10 = (char *) 0 ;
13521 PLFLT arg11 ;
13522 PLINT arg12 ;
13523 int res1 ;
13524 char *buf1 = 0 ;
13525 int alloc1 = 0 ;
13526 int res2 ;
13527 char *buf2 = 0 ;
13528 int alloc2 = 0 ;
13529 double val3 ;
13530 int ecode3 = 0 ;
13531 int val4 ;
13532 int ecode4 = 0 ;
13533 int res5 ;
13534 char *buf5 = 0 ;
13535 int alloc5 = 0 ;
13536 int res6 ;
13537 char *buf6 = 0 ;
13538 int alloc6 = 0 ;
13539 double val7 ;
13540 int ecode7 = 0 ;
13541 int val8 ;
13542 int ecode8 = 0 ;
13543 int res9 ;
13544 char *buf9 = 0 ;
13545 int alloc9 = 0 ;
13546 int res10 ;
13547 char *buf10 = 0 ;
13548 int alloc10 = 0 ;
13549 double val11 ;
13550 int ecode11 = 0 ;
13551 int val12 ;
13552 int ecode12 = 0 ;
13553 octave_value_list _out;
13554 octave_value_list *_outp=&_out;
13555 octave_value _outv;
13556
13557 if (!SWIG_check_num_args("plbox3",args.length(),12,12,0)) {
13558 SWIG_fail;
13559 }
13560 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
13561 if (!SWIG_IsOK(res1)) {
13562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plbox3" "', argument " "1"" of type '" "char const *""'");
13563 }
13564 arg1 = (char *)(buf1);
13565 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
13566 if (!SWIG_IsOK(res2)) {
13567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plbox3" "', argument " "2"" of type '" "char const *""'");
13568 }
13569 arg2 = (char *)(buf2);
13570 ecode3 = SWIG_AsVal_double(args(2), &val3);
13571 if (!SWIG_IsOK(ecode3)) {
13572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plbox3" "', argument " "3"" of type '" "PLFLT""'");
13573 }
13574 arg3 = (PLFLT)(val3);
13575 ecode4 = SWIG_AsVal_int(args(3), &val4);
13576 if (!SWIG_IsOK(ecode4)) {
13577 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plbox3" "', argument " "4"" of type '" "PLINT""'");
13578 }
13579 arg4 = (PLINT)(val4);
13580 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
13581 if (!SWIG_IsOK(res5)) {
13582 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plbox3" "', argument " "5"" of type '" "char const *""'");
13583 }
13584 arg5 = (char *)(buf5);
13585 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
13586 if (!SWIG_IsOK(res6)) {
13587 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plbox3" "', argument " "6"" of type '" "char const *""'");
13588 }
13589 arg6 = (char *)(buf6);
13590 ecode7 = SWIG_AsVal_double(args(6), &val7);
13591 if (!SWIG_IsOK(ecode7)) {
13592 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plbox3" "', argument " "7"" of type '" "PLFLT""'");
13593 }
13594 arg7 = (PLFLT)(val7);
13595 ecode8 = SWIG_AsVal_int(args(7), &val8);
13596 if (!SWIG_IsOK(ecode8)) {
13597 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plbox3" "', argument " "8"" of type '" "PLINT""'");
13598 }
13599 arg8 = (PLINT)(val8);
13600 res9 = SWIG_AsCharPtrAndSize(args(8), &buf9, NULL, &alloc9);
13601 if (!SWIG_IsOK(res9)) {
13602 SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "plbox3" "', argument " "9"" of type '" "char const *""'");
13603 }
13604 arg9 = (char *)(buf9);
13605 res10 = SWIG_AsCharPtrAndSize(args(9), &buf10, NULL, &alloc10);
13606 if (!SWIG_IsOK(res10)) {
13607 SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "plbox3" "', argument " "10"" of type '" "char const *""'");
13608 }
13609 arg10 = (char *)(buf10);
13610 ecode11 = SWIG_AsVal_double(args(10), &val11);
13611 if (!SWIG_IsOK(ecode11)) {
13612 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plbox3" "', argument " "11"" of type '" "PLFLT""'");
13613 }
13614 arg11 = (PLFLT)(val11);
13615 ecode12 = SWIG_AsVal_int(args(11), &val12);
13616 if (!SWIG_IsOK(ecode12)) {
13617 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "plbox3" "', argument " "12"" of type '" "PLINT""'");
13618 }
13619 arg12 = (PLINT)(val12);
13620 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);
13621 _outv = octave_value();
13622 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13623 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
13624 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
13625 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
13626 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
13627 if (alloc9 == SWIG_NEWOBJ) delete[] buf9;
13628 if (alloc10 == SWIG_NEWOBJ) delete[] buf10;
13629 fail:
13630 return _out;
13631 }
13632
13633
13634 SWIG_DEFUN( plcalc_world, _wrap_plcalc_world, _wrap_plcalc_world_texinfo ) {
13635 PLFLT arg1 ;
13636 PLFLT arg2 ;
13637 PLFLT *arg3 = (PLFLT *) 0 ;
13638 PLFLT *arg4 = (PLFLT *) 0 ;
13639 PLINT *arg5 = (PLINT *) 0 ;
13640 double val1 ;
13641 int ecode1 = 0 ;
13642 double val2 ;
13643 int ecode2 = 0 ;
13644 PLFLT temp3 ;
13645 int res3 = SWIG_TMPOBJ ;
13646 PLFLT temp4 ;
13647 int res4 = SWIG_TMPOBJ ;
13648 PLINT temp5 ;
13649 int res5 = SWIG_TMPOBJ ;
13650 octave_value_list _out;
13651 octave_value_list *_outp=&_out;
13652 octave_value _outv;
13653
13654 arg3 = &temp3;
13655 arg4 = &temp4;
13656 arg5 = &temp5;
13657 if (!SWIG_check_num_args("plcalc_world",args.length(),2,2,0)) {
13658 SWIG_fail;
13659 }
13660 ecode1 = SWIG_AsVal_double(args(0), &val1);
13661 if (!SWIG_IsOK(ecode1)) {
13662 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcalc_world" "', argument " "1"" of type '" "PLFLT""'");
13663 }
13664 arg1 = (PLFLT)(val1);
13665 ecode2 = SWIG_AsVal_double(args(1), &val2);
13666 if (!SWIG_IsOK(ecode2)) {
13667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcalc_world" "', argument " "2"" of type '" "PLFLT""'");
13668 }
13669 arg2 = (PLFLT)(val2);
13670 plcalc_world(arg1,arg2,arg3,arg4,arg5);
13671 _outv = octave_value();
13672 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13673 if (SWIG_IsTmpObj(res3)) {
13674 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
13675 } else {
13676 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13677 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
13678 }
13679 if (SWIG_IsTmpObj(res4)) {
13680 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
13681 } else {
13682 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13683 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
13684 }
13685 if (SWIG_IsTmpObj(res5)) {
13686 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
13687 } else {
13688 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13689 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
13690 }
13691 fail:
13692 return _out;
13693 }
13694
13695
13696 SWIG_DEFUN( plclear, _wrap_plclear, _wrap_plclear_texinfo ) {
13697 octave_value_list _out;
13698 octave_value_list *_outp=&_out;
13699 octave_value _outv;
13700
13701 if (!SWIG_check_num_args("plclear",args.length(),0,0,0)) {
13702 SWIG_fail;
13703 }
13704 plclear();
13705 _outv = octave_value();
13706 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13707 fail:
13708 return _out;
13709 }
13710
13711
13712 SWIG_DEFUN( plcol0, _wrap_plcol0, _wrap_plcol0_texinfo ) {
13713 PLINT arg1 ;
13714 int val1 ;
13715 int ecode1 = 0 ;
13716 octave_value_list _out;
13717 octave_value_list *_outp=&_out;
13718 octave_value _outv;
13719
13720 if (!SWIG_check_num_args("plcol0",args.length(),1,1,0)) {
13721 SWIG_fail;
13722 }
13723 ecode1 = SWIG_AsVal_int(args(0), &val1);
13724 if (!SWIG_IsOK(ecode1)) {
13725 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol0" "', argument " "1"" of type '" "PLINT""'");
13726 }
13727 arg1 = (PLINT)(val1);
13728 plcol0(arg1);
13729 _outv = octave_value();
13730 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13731 fail:
13732 return _out;
13733 }
13734
13735
13736 SWIG_DEFUN( plcol1, _wrap_plcol1, _wrap_plcol1_texinfo ) {
13737 PLFLT arg1 ;
13738 double val1 ;
13739 int ecode1 = 0 ;
13740 octave_value_list _out;
13741 octave_value_list *_outp=&_out;
13742 octave_value _outv;
13743
13744 if (!SWIG_check_num_args("plcol1",args.length(),1,1,0)) {
13745 SWIG_fail;
13746 }
13747 ecode1 = SWIG_AsVal_double(args(0), &val1);
13748 if (!SWIG_IsOK(ecode1)) {
13749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcol1" "', argument " "1"" of type '" "PLFLT""'");
13750 }
13751 arg1 = (PLFLT)(val1);
13752 plcol1(arg1);
13753 _outv = octave_value();
13754 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13755 fail:
13756 return _out;
13757 }
13758
13759
13760 SWIG_DEFUN( plconfigtime, _wrap_plconfigtime, std::string() ) {
13761 PLFLT arg1 ;
13762 PLFLT arg2 ;
13763 PLFLT arg3 ;
13764 PLINT arg4 ;
13765 PLBOOL arg5 ;
13766 PLINT arg6 ;
13767 PLINT arg7 ;
13768 PLINT arg8 ;
13769 PLINT arg9 ;
13770 PLINT arg10 ;
13771 PLFLT arg11 ;
13772 double val1 ;
13773 int ecode1 = 0 ;
13774 double val2 ;
13775 int ecode2 = 0 ;
13776 double val3 ;
13777 int ecode3 = 0 ;
13778 int val4 ;
13779 int ecode4 = 0 ;
13780 int val5 ;
13781 int ecode5 = 0 ;
13782 int val6 ;
13783 int ecode6 = 0 ;
13784 int val7 ;
13785 int ecode7 = 0 ;
13786 int val8 ;
13787 int ecode8 = 0 ;
13788 int val9 ;
13789 int ecode9 = 0 ;
13790 int val10 ;
13791 int ecode10 = 0 ;
13792 double val11 ;
13793 int ecode11 = 0 ;
13794 octave_value_list _out;
13795 octave_value_list *_outp=&_out;
13796 octave_value _outv;
13797
13798 if (!SWIG_check_num_args("plconfigtime",args.length(),11,11,0)) {
13799 SWIG_fail;
13800 }
13801 ecode1 = SWIG_AsVal_double(args(0), &val1);
13802 if (!SWIG_IsOK(ecode1)) {
13803 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plconfigtime" "', argument " "1"" of type '" "PLFLT""'");
13804 }
13805 arg1 = (PLFLT)(val1);
13806 ecode2 = SWIG_AsVal_double(args(1), &val2);
13807 if (!SWIG_IsOK(ecode2)) {
13808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plconfigtime" "', argument " "2"" of type '" "PLFLT""'");
13809 }
13810 arg2 = (PLFLT)(val2);
13811 ecode3 = SWIG_AsVal_double(args(2), &val3);
13812 if (!SWIG_IsOK(ecode3)) {
13813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plconfigtime" "', argument " "3"" of type '" "PLFLT""'");
13814 }
13815 arg3 = (PLFLT)(val3);
13816 ecode4 = SWIG_AsVal_int(args(3), &val4);
13817 if (!SWIG_IsOK(ecode4)) {
13818 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plconfigtime" "', argument " "4"" of type '" "PLINT""'");
13819 }
13820 arg4 = (PLINT)(val4);
13821 ecode5 = SWIG_AsVal_int(args(4), &val5);
13822 if (!SWIG_IsOK(ecode5)) {
13823 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plconfigtime" "', argument " "5"" of type '" "PLBOOL""'");
13824 }
13825 arg5 = (PLBOOL)(val5);
13826 ecode6 = SWIG_AsVal_int(args(5), &val6);
13827 if (!SWIG_IsOK(ecode6)) {
13828 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plconfigtime" "', argument " "6"" of type '" "PLINT""'");
13829 }
13830 arg6 = (PLINT)(val6);
13831 ecode7 = SWIG_AsVal_int(args(6), &val7);
13832 if (!SWIG_IsOK(ecode7)) {
13833 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plconfigtime" "', argument " "7"" of type '" "PLINT""'");
13834 }
13835 arg7 = (PLINT)(val7);
13836 ecode8 = SWIG_AsVal_int(args(7), &val8);
13837 if (!SWIG_IsOK(ecode8)) {
13838 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plconfigtime" "', argument " "8"" of type '" "PLINT""'");
13839 }
13840 arg8 = (PLINT)(val8);
13841 ecode9 = SWIG_AsVal_int(args(8), &val9);
13842 if (!SWIG_IsOK(ecode9)) {
13843 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plconfigtime" "', argument " "9"" of type '" "PLINT""'");
13844 }
13845 arg9 = (PLINT)(val9);
13846 ecode10 = SWIG_AsVal_int(args(9), &val10);
13847 if (!SWIG_IsOK(ecode10)) {
13848 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plconfigtime" "', argument " "10"" of type '" "PLINT""'");
13849 }
13850 arg10 = (PLINT)(val10);
13851 ecode11 = SWIG_AsVal_double(args(10), &val11);
13852 if (!SWIG_IsOK(ecode11)) {
13853 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plconfigtime" "', argument " "11"" of type '" "PLFLT""'");
13854 }
13855 arg11 = (PLFLT)(val11);
13856 plconfigtime(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
13857 _outv = octave_value();
13858 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13859 fail:
13860 return _out;
13861 }
13862
13863
13864 SWIG_DEFUN( plctime, _wrap_plctime, std::string() ) {
13865 PLINT arg1 ;
13866 PLINT arg2 ;
13867 PLINT arg3 ;
13868 PLINT arg4 ;
13869 PLINT arg5 ;
13870 PLFLT arg6 ;
13871 PLFLT *arg7 = (PLFLT *) 0 ;
13872 int val1 ;
13873 int ecode1 = 0 ;
13874 int val2 ;
13875 int ecode2 = 0 ;
13876 int val3 ;
13877 int ecode3 = 0 ;
13878 int val4 ;
13879 int ecode4 = 0 ;
13880 int val5 ;
13881 int ecode5 = 0 ;
13882 double val6 ;
13883 int ecode6 = 0 ;
13884 PLFLT temp7 ;
13885 int res7 = SWIG_TMPOBJ ;
13886 octave_value_list _out;
13887 octave_value_list *_outp=&_out;
13888 octave_value _outv;
13889
13890 arg7 = &temp7;
13891 if (!SWIG_check_num_args("plctime",args.length(),6,6,0)) {
13892 SWIG_fail;
13893 }
13894 ecode1 = SWIG_AsVal_int(args(0), &val1);
13895 if (!SWIG_IsOK(ecode1)) {
13896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plctime" "', argument " "1"" of type '" "PLINT""'");
13897 }
13898 arg1 = (PLINT)(val1);
13899 ecode2 = SWIG_AsVal_int(args(1), &val2);
13900 if (!SWIG_IsOK(ecode2)) {
13901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plctime" "', argument " "2"" of type '" "PLINT""'");
13902 }
13903 arg2 = (PLINT)(val2);
13904 ecode3 = SWIG_AsVal_int(args(2), &val3);
13905 if (!SWIG_IsOK(ecode3)) {
13906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plctime" "', argument " "3"" of type '" "PLINT""'");
13907 }
13908 arg3 = (PLINT)(val3);
13909 ecode4 = SWIG_AsVal_int(args(3), &val4);
13910 if (!SWIG_IsOK(ecode4)) {
13911 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plctime" "', argument " "4"" of type '" "PLINT""'");
13912 }
13913 arg4 = (PLINT)(val4);
13914 ecode5 = SWIG_AsVal_int(args(4), &val5);
13915 if (!SWIG_IsOK(ecode5)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plctime" "', argument " "5"" of type '" "PLINT""'");
13917 }
13918 arg5 = (PLINT)(val5);
13919 ecode6 = SWIG_AsVal_double(args(5), &val6);
13920 if (!SWIG_IsOK(ecode6)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plctime" "', argument " "6"" of type '" "PLFLT""'");
13922 }
13923 arg6 = (PLFLT)(val6);
13924 plctime(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
13925 _outv = octave_value();
13926 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13927 if (SWIG_IsTmpObj(res7)) {
13928 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg7)));
13929 } else {
13930 int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
13931 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
13932 }
13933 fail:
13934 return _out;
13935 }
13936
13937
13938 SWIG_DEFUN( plcpstrm, _wrap_plcpstrm, _wrap_plcpstrm_texinfo ) {
13939 PLINT arg1 ;
13940 PLBOOL arg2 ;
13941 int val1 ;
13942 int ecode1 = 0 ;
13943 int val2 ;
13944 int ecode2 = 0 ;
13945 octave_value_list _out;
13946 octave_value_list *_outp=&_out;
13947 octave_value _outv;
13948
13949 if (!SWIG_check_num_args("plcpstrm",args.length(),2,2,0)) {
13950 SWIG_fail;
13951 }
13952 ecode1 = SWIG_AsVal_int(args(0), &val1);
13953 if (!SWIG_IsOK(ecode1)) {
13954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plcpstrm" "', argument " "1"" of type '" "PLINT""'");
13955 }
13956 arg1 = (PLINT)(val1);
13957 ecode2 = SWIG_AsVal_int(args(1), &val2);
13958 if (!SWIG_IsOK(ecode2)) {
13959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plcpstrm" "', argument " "2"" of type '" "PLBOOL""'");
13960 }
13961 arg2 = (PLBOOL)(val2);
13962 plcpstrm(arg1,arg2);
13963 _outv = octave_value();
13964 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13965 fail:
13966 return _out;
13967 }
13968
13969
13970 SWIG_DEFUN( plend, _wrap_plend, _wrap_plend_texinfo ) {
13971 octave_value_list _out;
13972 octave_value_list *_outp=&_out;
13973 octave_value _outv;
13974
13975 if (!SWIG_check_num_args("plend",args.length(),0,0,0)) {
13976 SWIG_fail;
13977 }
13978 plend();
13979 _outv = octave_value();
13980 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13981 fail:
13982 return _out;
13983 }
13984
13985
13986 SWIG_DEFUN( plend1, _wrap_plend1, _wrap_plend1_texinfo ) {
13987 octave_value_list _out;
13988 octave_value_list *_outp=&_out;
13989 octave_value _outv;
13990
13991 if (!SWIG_check_num_args("plend1",args.length(),0,0,0)) {
13992 SWIG_fail;
13993 }
13994 plend1();
13995 _outv = octave_value();
13996 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
13997 fail:
13998 return _out;
13999 }
14000
14001
14002 SWIG_DEFUN( plenv, _wrap_plenv, _wrap_plenv_texinfo ) {
14003 PLFLT arg1 ;
14004 PLFLT arg2 ;
14005 PLFLT arg3 ;
14006 PLFLT arg4 ;
14007 PLINT arg5 ;
14008 PLINT arg6 ;
14009 double val1 ;
14010 int ecode1 = 0 ;
14011 double val2 ;
14012 int ecode2 = 0 ;
14013 double val3 ;
14014 int ecode3 = 0 ;
14015 double val4 ;
14016 int ecode4 = 0 ;
14017 int val5 ;
14018 int ecode5 = 0 ;
14019 int val6 ;
14020 int ecode6 = 0 ;
14021 octave_value_list _out;
14022 octave_value_list *_outp=&_out;
14023 octave_value _outv;
14024
14025 if (!SWIG_check_num_args("plenv",args.length(),6,6,0)) {
14026 SWIG_fail;
14027 }
14028 ecode1 = SWIG_AsVal_double(args(0), &val1);
14029 if (!SWIG_IsOK(ecode1)) {
14030 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv" "', argument " "1"" of type '" "PLFLT""'");
14031 }
14032 arg1 = (PLFLT)(val1);
14033 ecode2 = SWIG_AsVal_double(args(1), &val2);
14034 if (!SWIG_IsOK(ecode2)) {
14035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv" "', argument " "2"" of type '" "PLFLT""'");
14036 }
14037 arg2 = (PLFLT)(val2);
14038 ecode3 = SWIG_AsVal_double(args(2), &val3);
14039 if (!SWIG_IsOK(ecode3)) {
14040 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv" "', argument " "3"" of type '" "PLFLT""'");
14041 }
14042 arg3 = (PLFLT)(val3);
14043 ecode4 = SWIG_AsVal_double(args(3), &val4);
14044 if (!SWIG_IsOK(ecode4)) {
14045 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv" "', argument " "4"" of type '" "PLFLT""'");
14046 }
14047 arg4 = (PLFLT)(val4);
14048 ecode5 = SWIG_AsVal_int(args(4), &val5);
14049 if (!SWIG_IsOK(ecode5)) {
14050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv" "', argument " "5"" of type '" "PLINT""'");
14051 }
14052 arg5 = (PLINT)(val5);
14053 ecode6 = SWIG_AsVal_int(args(5), &val6);
14054 if (!SWIG_IsOK(ecode6)) {
14055 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv" "', argument " "6"" of type '" "PLINT""'");
14056 }
14057 arg6 = (PLINT)(val6);
14058 plenv(arg1,arg2,arg3,arg4,arg5,arg6);
14059 _outv = octave_value();
14060 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14061 fail:
14062 return _out;
14063 }
14064
14065
14066 SWIG_DEFUN( plenv0, _wrap_plenv0, _wrap_plenv0_texinfo ) {
14067 PLFLT arg1 ;
14068 PLFLT arg2 ;
14069 PLFLT arg3 ;
14070 PLFLT arg4 ;
14071 PLINT arg5 ;
14072 PLINT arg6 ;
14073 double val1 ;
14074 int ecode1 = 0 ;
14075 double val2 ;
14076 int ecode2 = 0 ;
14077 double val3 ;
14078 int ecode3 = 0 ;
14079 double val4 ;
14080 int ecode4 = 0 ;
14081 int val5 ;
14082 int ecode5 = 0 ;
14083 int val6 ;
14084 int ecode6 = 0 ;
14085 octave_value_list _out;
14086 octave_value_list *_outp=&_out;
14087 octave_value _outv;
14088
14089 if (!SWIG_check_num_args("plenv0",args.length(),6,6,0)) {
14090 SWIG_fail;
14091 }
14092 ecode1 = SWIG_AsVal_double(args(0), &val1);
14093 if (!SWIG_IsOK(ecode1)) {
14094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plenv0" "', argument " "1"" of type '" "PLFLT""'");
14095 }
14096 arg1 = (PLFLT)(val1);
14097 ecode2 = SWIG_AsVal_double(args(1), &val2);
14098 if (!SWIG_IsOK(ecode2)) {
14099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plenv0" "', argument " "2"" of type '" "PLFLT""'");
14100 }
14101 arg2 = (PLFLT)(val2);
14102 ecode3 = SWIG_AsVal_double(args(2), &val3);
14103 if (!SWIG_IsOK(ecode3)) {
14104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plenv0" "', argument " "3"" of type '" "PLFLT""'");
14105 }
14106 arg3 = (PLFLT)(val3);
14107 ecode4 = SWIG_AsVal_double(args(3), &val4);
14108 if (!SWIG_IsOK(ecode4)) {
14109 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plenv0" "', argument " "4"" of type '" "PLFLT""'");
14110 }
14111 arg4 = (PLFLT)(val4);
14112 ecode5 = SWIG_AsVal_int(args(4), &val5);
14113 if (!SWIG_IsOK(ecode5)) {
14114 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plenv0" "', argument " "5"" of type '" "PLINT""'");
14115 }
14116 arg5 = (PLINT)(val5);
14117 ecode6 = SWIG_AsVal_int(args(5), &val6);
14118 if (!SWIG_IsOK(ecode6)) {
14119 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plenv0" "', argument " "6"" of type '" "PLINT""'");
14120 }
14121 arg6 = (PLINT)(val6);
14122 plenv0(arg1,arg2,arg3,arg4,arg5,arg6);
14123 _outv = octave_value();
14124 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14125 fail:
14126 return _out;
14127 }
14128
14129
14130 SWIG_DEFUN( pleop, _wrap_pleop, _wrap_pleop_texinfo ) {
14131 octave_value_list _out;
14132 octave_value_list *_outp=&_out;
14133 octave_value _outv;
14134
14135 if (!SWIG_check_num_args("pleop",args.length(),0,0,0)) {
14136 SWIG_fail;
14137 }
14138 pleop();
14139 _outv = octave_value();
14140 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14141 fail:
14142 return _out;
14143 }
14144
14145
14146 SWIG_DEFUN( plerrx, _wrap_plerrx, _wrap_plerrx_texinfo ) {
14147 PLINT arg1 ;
14148 PLFLT *arg2 = (PLFLT *) 0 ;
14149 PLFLT *arg3 = (PLFLT *) 0 ;
14150 PLFLT *arg4 = (PLFLT *) 0 ;
14151 Matrix temp1 ;
14152 Matrix temp3 ;
14153 Matrix temp4 ;
14154 octave_value_list _out;
14155 octave_value_list *_outp=&_out;
14156 octave_value _outv;
14157
14158 if (!SWIG_check_num_args("plerrx",args.length(),3,3,0)) {
14159 SWIG_fail;
14160 }
14161 {
14162 if ( _n_dims( args(0) ) > 1 )
14163 {
14164 error( "argument must be a scalar or vector" ); SWIG_fail;
14165 }
14166 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14167 temp1 = args(0).matrix_value();
14168 arg2 = &temp1( 0, 0 );
14169 }
14170 {
14171 if ( _n_dims( args(1) ) > 1 )
14172 {
14173 error( "argument must be a scalar or vector" ); SWIG_fail;
14174 }
14175 if ( _dim( args(1), 0 ) != Alen )
14176 {
14177 error( "argument vectors must be same length" ); SWIG_fail;
14178 }
14179 temp3 = args(1).matrix_value();
14180 arg3 = &temp3( 0, 0 );
14181 }
14182 {
14183 if ( _n_dims( args(2) ) > 1 )
14184 {
14185 error( "argument must be a scalar or vector" ); SWIG_fail;
14186 }
14187 if ( _dim( args(2), 0 ) != Alen )
14188 {
14189 error( "argument vectors must be same length" ); SWIG_fail;
14190 }
14191 temp4 = args(2).matrix_value();
14192 arg4 = &temp4( 0, 0 );
14193 }
14194 plerrx(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
14195 _outv = octave_value();
14196 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14197 {
14198
14199 }
14200 {
14201
14202 }
14203 {
14204
14205 }
14206 fail:
14207 return _out;
14208 }
14209
14210
14211 SWIG_DEFUN( plerry, _wrap_plerry, _wrap_plerry_texinfo ) {
14212 PLINT arg1 ;
14213 PLFLT *arg2 = (PLFLT *) 0 ;
14214 PLFLT *arg3 = (PLFLT *) 0 ;
14215 PLFLT *arg4 = (PLFLT *) 0 ;
14216 Matrix temp1 ;
14217 Matrix temp3 ;
14218 Matrix temp4 ;
14219 octave_value_list _out;
14220 octave_value_list *_outp=&_out;
14221 octave_value _outv;
14222
14223 if (!SWIG_check_num_args("plerry",args.length(),3,3,0)) {
14224 SWIG_fail;
14225 }
14226 {
14227 if ( _n_dims( args(0) ) > 1 )
14228 {
14229 error( "argument must be a scalar or vector" ); SWIG_fail;
14230 }
14231 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14232 temp1 = args(0).matrix_value();
14233 arg2 = &temp1( 0, 0 );
14234 }
14235 {
14236 if ( _n_dims( args(1) ) > 1 )
14237 {
14238 error( "argument must be a scalar or vector" ); SWIG_fail;
14239 }
14240 if ( _dim( args(1), 0 ) != Alen )
14241 {
14242 error( "argument vectors must be same length" ); SWIG_fail;
14243 }
14244 temp3 = args(1).matrix_value();
14245 arg3 = &temp3( 0, 0 );
14246 }
14247 {
14248 if ( _n_dims( args(2) ) > 1 )
14249 {
14250 error( "argument must be a scalar or vector" ); SWIG_fail;
14251 }
14252 if ( _dim( args(2), 0 ) != Alen )
14253 {
14254 error( "argument vectors must be same length" ); SWIG_fail;
14255 }
14256 temp4 = args(2).matrix_value();
14257 arg4 = &temp4( 0, 0 );
14258 }
14259 plerry(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
14260 _outv = octave_value();
14261 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14262 {
14263
14264 }
14265 {
14266
14267 }
14268 {
14269
14270 }
14271 fail:
14272 return _out;
14273 }
14274
14275
14276 SWIG_DEFUN( plfamadv, _wrap_plfamadv, _wrap_plfamadv_texinfo ) {
14277 octave_value_list _out;
14278 octave_value_list *_outp=&_out;
14279 octave_value _outv;
14280
14281 if (!SWIG_check_num_args("plfamadv",args.length(),0,0,0)) {
14282 SWIG_fail;
14283 }
14284 plfamadv();
14285 _outv = octave_value();
14286 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14287 fail:
14288 return _out;
14289 }
14290
14291
14292 SWIG_DEFUN( plfill, _wrap_plfill, _wrap_plfill_texinfo ) {
14293 PLINT arg1 ;
14294 PLFLT *arg2 = (PLFLT *) 0 ;
14295 PLFLT *arg3 = (PLFLT *) 0 ;
14296 Matrix temp1 ;
14297 Matrix temp3 ;
14298 octave_value_list _out;
14299 octave_value_list *_outp=&_out;
14300 octave_value _outv;
14301
14302 if (!SWIG_check_num_args("plfill",args.length(),2,2,0)) {
14303 SWIG_fail;
14304 }
14305 {
14306 if ( _n_dims( args(0) ) > 1 )
14307 {
14308 error( "argument must be a scalar or vector" ); SWIG_fail;
14309 }
14310 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14311 temp1 = args(0).matrix_value();
14312 arg2 = &temp1( 0, 0 );
14313 }
14314 {
14315 if ( _n_dims( args(1) ) > 1 )
14316 {
14317 error( "argument must be a scalar or vector" ); SWIG_fail;
14318 }
14319 if ( _dim( args(1), 0 ) != Alen )
14320 {
14321 error( "argument vectors must be same length" ); SWIG_fail;
14322 }
14323 temp3 = args(1).matrix_value();
14324 arg3 = &temp3( 0, 0 );
14325 }
14326 plfill(arg1,(double const *)arg2,(double const *)arg3);
14327 _outv = octave_value();
14328 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14329 {
14330
14331 }
14332 {
14333
14334 }
14335 fail:
14336 return _out;
14337 }
14338
14339
14340 SWIG_DEFUN( plfill3, _wrap_plfill3, _wrap_plfill3_texinfo ) {
14341 PLINT arg1 ;
14342 PLFLT *arg2 = (PLFLT *) 0 ;
14343 PLFLT *arg3 = (PLFLT *) 0 ;
14344 PLFLT *arg4 = (PLFLT *) 0 ;
14345 Matrix temp1 ;
14346 Matrix temp3 ;
14347 Matrix temp4 ;
14348 octave_value_list _out;
14349 octave_value_list *_outp=&_out;
14350 octave_value _outv;
14351
14352 if (!SWIG_check_num_args("plfill3",args.length(),3,3,0)) {
14353 SWIG_fail;
14354 }
14355 {
14356 if ( _n_dims( args(0) ) > 1 )
14357 {
14358 error( "argument must be a scalar or vector" ); SWIG_fail;
14359 }
14360 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14361 temp1 = args(0).matrix_value();
14362 arg2 = &temp1( 0, 0 );
14363 }
14364 {
14365 if ( _n_dims( args(1) ) > 1 )
14366 {
14367 error( "argument must be a scalar or vector" ); SWIG_fail;
14368 }
14369 if ( _dim( args(1), 0 ) != Alen )
14370 {
14371 error( "argument vectors must be same length" ); SWIG_fail;
14372 }
14373 temp3 = args(1).matrix_value();
14374 arg3 = &temp3( 0, 0 );
14375 }
14376 {
14377 if ( _n_dims( args(2) ) > 1 )
14378 {
14379 error( "argument must be a scalar or vector" ); SWIG_fail;
14380 }
14381 if ( _dim( args(2), 0 ) != Alen )
14382 {
14383 error( "argument vectors must be same length" ); SWIG_fail;
14384 }
14385 temp4 = args(2).matrix_value();
14386 arg4 = &temp4( 0, 0 );
14387 }
14388 plfill3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
14389 _outv = octave_value();
14390 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14391 {
14392
14393 }
14394 {
14395
14396 }
14397 {
14398
14399 }
14400 fail:
14401 return _out;
14402 }
14403
14404
14405 SWIG_DEFUN( plgradient, _wrap_plgradient, _wrap_plgradient_texinfo ) {
14406 PLINT arg1 ;
14407 PLFLT *arg2 = (PLFLT *) 0 ;
14408 PLFLT *arg3 = (PLFLT *) 0 ;
14409 PLFLT arg4 ;
14410 Matrix temp1 ;
14411 Matrix temp3 ;
14412 double val4 ;
14413 int ecode4 = 0 ;
14414 octave_value_list _out;
14415 octave_value_list *_outp=&_out;
14416 octave_value _outv;
14417
14418 if (!SWIG_check_num_args("plgradient",args.length(),3,3,0)) {
14419 SWIG_fail;
14420 }
14421 {
14422 if ( _n_dims( args(0) ) > 1 )
14423 {
14424 error( "argument must be a scalar or vector" ); SWIG_fail;
14425 }
14426 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
14427 temp1 = args(0).matrix_value();
14428 arg2 = &temp1( 0, 0 );
14429 }
14430 {
14431 if ( _n_dims( args(1) ) > 1 )
14432 {
14433 error( "argument must be a scalar or vector" ); SWIG_fail;
14434 }
14435 if ( _dim( args(1), 0 ) != Alen )
14436 {
14437 error( "argument vectors must be same length" ); SWIG_fail;
14438 }
14439 temp3 = args(1).matrix_value();
14440 arg3 = &temp3( 0, 0 );
14441 }
14442 ecode4 = SWIG_AsVal_double(args(2), &val4);
14443 if (!SWIG_IsOK(ecode4)) {
14444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plgradient" "', argument " "4"" of type '" "PLFLT""'");
14445 }
14446 arg4 = (PLFLT)(val4);
14447 plgradient(arg1,(double const *)arg2,(double const *)arg3,arg4);
14448 _outv = octave_value();
14449 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14450 {
14451
14452 }
14453 {
14454
14455 }
14456 fail:
14457 return _out;
14458 }
14459
14460
14461 SWIG_DEFUN( plflush, _wrap_plflush, _wrap_plflush_texinfo ) {
14462 octave_value_list _out;
14463 octave_value_list *_outp=&_out;
14464 octave_value _outv;
14465
14466 if (!SWIG_check_num_args("plflush",args.length(),0,0,0)) {
14467 SWIG_fail;
14468 }
14469 plflush();
14470 _outv = octave_value();
14471 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14472 fail:
14473 return _out;
14474 }
14475
14476
14477 SWIG_DEFUN( plfont, _wrap_plfont, _wrap_plfont_texinfo ) {
14478 PLINT arg1 ;
14479 int val1 ;
14480 int ecode1 = 0 ;
14481 octave_value_list _out;
14482 octave_value_list *_outp=&_out;
14483 octave_value _outv;
14484
14485 if (!SWIG_check_num_args("plfont",args.length(),1,1,0)) {
14486 SWIG_fail;
14487 }
14488 ecode1 = SWIG_AsVal_int(args(0), &val1);
14489 if (!SWIG_IsOK(ecode1)) {
14490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfont" "', argument " "1"" of type '" "PLINT""'");
14491 }
14492 arg1 = (PLINT)(val1);
14493 plfont(arg1);
14494 _outv = octave_value();
14495 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14496 fail:
14497 return _out;
14498 }
14499
14500
14501 SWIG_DEFUN( plfontld, _wrap_plfontld, _wrap_plfontld_texinfo ) {
14502 PLINT arg1 ;
14503 int val1 ;
14504 int ecode1 = 0 ;
14505 octave_value_list _out;
14506 octave_value_list *_outp=&_out;
14507 octave_value _outv;
14508
14509 if (!SWIG_check_num_args("plfontld",args.length(),1,1,0)) {
14510 SWIG_fail;
14511 }
14512 ecode1 = SWIG_AsVal_int(args(0), &val1);
14513 if (!SWIG_IsOK(ecode1)) {
14514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plfontld" "', argument " "1"" of type '" "PLINT""'");
14515 }
14516 arg1 = (PLINT)(val1);
14517 plfontld(arg1);
14518 _outv = octave_value();
14519 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14520 fail:
14521 return _out;
14522 }
14523
14524
14525 SWIG_DEFUN( plgchr, _wrap_plgchr, _wrap_plgchr_texinfo ) {
14526 PLFLT *arg1 = (PLFLT *) 0 ;
14527 PLFLT *arg2 = (PLFLT *) 0 ;
14528 PLFLT temp1 ;
14529 int res1 = SWIG_TMPOBJ ;
14530 PLFLT temp2 ;
14531 int res2 = SWIG_TMPOBJ ;
14532 octave_value_list _out;
14533 octave_value_list *_outp=&_out;
14534 octave_value _outv;
14535
14536 arg1 = &temp1;
14537 arg2 = &temp2;
14538 if (!SWIG_check_num_args("plgchr",args.length(),0,0,0)) {
14539 SWIG_fail;
14540 }
14541 plgchr(arg1,arg2);
14542 _outv = octave_value();
14543 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14544 if (SWIG_IsTmpObj(res1)) {
14545 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14546 } else {
14547 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14548 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14549 }
14550 if (SWIG_IsTmpObj(res2)) {
14551 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
14552 } else {
14553 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14554 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
14555 }
14556 fail:
14557 return _out;
14558 }
14559
14560
14561 SWIG_DEFUN( plgcol0, _wrap_plgcol0, _wrap_plgcol0_texinfo ) {
14562 PLINT arg1 ;
14563 PLINT *arg2 = (PLINT *) 0 ;
14564 PLINT *arg3 = (PLINT *) 0 ;
14565 PLINT *arg4 = (PLINT *) 0 ;
14566 int val1 ;
14567 int ecode1 = 0 ;
14568 PLINT temp2 ;
14569 int res2 = SWIG_TMPOBJ ;
14570 PLINT temp3 ;
14571 int res3 = SWIG_TMPOBJ ;
14572 PLINT temp4 ;
14573 int res4 = SWIG_TMPOBJ ;
14574 octave_value_list _out;
14575 octave_value_list *_outp=&_out;
14576 octave_value _outv;
14577
14578 arg2 = &temp2;
14579 arg3 = &temp3;
14580 arg4 = &temp4;
14581 if (!SWIG_check_num_args("plgcol0",args.length(),1,1,0)) {
14582 SWIG_fail;
14583 }
14584 ecode1 = SWIG_AsVal_int(args(0), &val1);
14585 if (!SWIG_IsOK(ecode1)) {
14586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0" "', argument " "1"" of type '" "PLINT""'");
14587 }
14588 arg1 = (PLINT)(val1);
14589 plgcol0(arg1,arg2,arg3,arg4);
14590 _outv = octave_value();
14591 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14592 if (SWIG_IsTmpObj(res2)) {
14593 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
14594 } else {
14595 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14596 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14597 }
14598 if (SWIG_IsTmpObj(res3)) {
14599 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
14600 } else {
14601 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14602 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
14603 }
14604 if (SWIG_IsTmpObj(res4)) {
14605 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
14606 } else {
14607 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14608 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
14609 }
14610 fail:
14611 return _out;
14612 }
14613
14614
14615 SWIG_DEFUN( plgcol0a, _wrap_plgcol0a, _wrap_plgcol0a_texinfo ) {
14616 PLINT arg1 ;
14617 PLINT *arg2 = (PLINT *) 0 ;
14618 PLINT *arg3 = (PLINT *) 0 ;
14619 PLINT *arg4 = (PLINT *) 0 ;
14620 PLFLT *arg5 = (PLFLT *) 0 ;
14621 int val1 ;
14622 int ecode1 = 0 ;
14623 PLINT temp2 ;
14624 int res2 = SWIG_TMPOBJ ;
14625 PLINT temp3 ;
14626 int res3 = SWIG_TMPOBJ ;
14627 PLINT temp4 ;
14628 int res4 = SWIG_TMPOBJ ;
14629 PLFLT temp5 ;
14630 int res5 = SWIG_TMPOBJ ;
14631 octave_value_list _out;
14632 octave_value_list *_outp=&_out;
14633 octave_value _outv;
14634
14635 arg2 = &temp2;
14636 arg3 = &temp3;
14637 arg4 = &temp4;
14638 arg5 = &temp5;
14639 if (!SWIG_check_num_args("plgcol0a",args.length(),1,1,0)) {
14640 SWIG_fail;
14641 }
14642 ecode1 = SWIG_AsVal_int(args(0), &val1);
14643 if (!SWIG_IsOK(ecode1)) {
14644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plgcol0a" "', argument " "1"" of type '" "PLINT""'");
14645 }
14646 arg1 = (PLINT)(val1);
14647 plgcol0a(arg1,arg2,arg3,arg4,arg5);
14648 _outv = octave_value();
14649 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14650 if (SWIG_IsTmpObj(res2)) {
14651 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
14652 } else {
14653 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14654 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14655 }
14656 if (SWIG_IsTmpObj(res3)) {
14657 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
14658 } else {
14659 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14660 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
14661 }
14662 if (SWIG_IsTmpObj(res4)) {
14663 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
14664 } else {
14665 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14666 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
14667 }
14668 if (SWIG_IsTmpObj(res5)) {
14669 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
14670 } else {
14671 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14672 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
14673 }
14674 fail:
14675 return _out;
14676 }
14677
14678
14679 SWIG_DEFUN( plgcolbg, _wrap_plgcolbg, _wrap_plgcolbg_texinfo ) {
14680 PLINT *arg1 = (PLINT *) 0 ;
14681 PLINT *arg2 = (PLINT *) 0 ;
14682 PLINT *arg3 = (PLINT *) 0 ;
14683 PLINT temp1 ;
14684 int res1 = SWIG_TMPOBJ ;
14685 PLINT temp2 ;
14686 int res2 = SWIG_TMPOBJ ;
14687 PLINT temp3 ;
14688 int res3 = SWIG_TMPOBJ ;
14689 octave_value_list _out;
14690 octave_value_list *_outp=&_out;
14691 octave_value _outv;
14692
14693 arg1 = &temp1;
14694 arg2 = &temp2;
14695 arg3 = &temp3;
14696 if (!SWIG_check_num_args("plgcolbg",args.length(),0,0,0)) {
14697 SWIG_fail;
14698 }
14699 plgcolbg(arg1,arg2,arg3);
14700 _outv = octave_value();
14701 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14702 if (SWIG_IsTmpObj(res1)) {
14703 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
14704 } else {
14705 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14706 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
14707 }
14708 if (SWIG_IsTmpObj(res2)) {
14709 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
14710 } else {
14711 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14712 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14713 }
14714 if (SWIG_IsTmpObj(res3)) {
14715 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
14716 } else {
14717 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14718 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
14719 }
14720 fail:
14721 return _out;
14722 }
14723
14724
14725 SWIG_DEFUN( plgcolbga, _wrap_plgcolbga, _wrap_plgcolbga_texinfo ) {
14726 PLINT *arg1 = (PLINT *) 0 ;
14727 PLINT *arg2 = (PLINT *) 0 ;
14728 PLINT *arg3 = (PLINT *) 0 ;
14729 PLFLT *arg4 = (PLFLT *) 0 ;
14730 PLINT temp1 ;
14731 int res1 = SWIG_TMPOBJ ;
14732 PLINT temp2 ;
14733 int res2 = SWIG_TMPOBJ ;
14734 PLINT temp3 ;
14735 int res3 = SWIG_TMPOBJ ;
14736 PLFLT temp4 ;
14737 int res4 = SWIG_TMPOBJ ;
14738 octave_value_list _out;
14739 octave_value_list *_outp=&_out;
14740 octave_value _outv;
14741
14742 arg1 = &temp1;
14743 arg2 = &temp2;
14744 arg3 = &temp3;
14745 arg4 = &temp4;
14746 if (!SWIG_check_num_args("plgcolbga",args.length(),0,0,0)) {
14747 SWIG_fail;
14748 }
14749 plgcolbga(arg1,arg2,arg3,arg4);
14750 _outv = octave_value();
14751 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14752 if (SWIG_IsTmpObj(res1)) {
14753 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
14754 } else {
14755 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14756 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
14757 }
14758 if (SWIG_IsTmpObj(res2)) {
14759 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
14760 } else {
14761 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14762 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
14763 }
14764 if (SWIG_IsTmpObj(res3)) {
14765 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
14766 } else {
14767 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14768 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
14769 }
14770 if (SWIG_IsTmpObj(res4)) {
14771 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
14772 } else {
14773 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14774 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14775 }
14776 fail:
14777 return _out;
14778 }
14779
14780
14781 SWIG_DEFUN( plgcompression, _wrap_plgcompression, _wrap_plgcompression_texinfo ) {
14782 PLINT *arg1 = (PLINT *) 0 ;
14783 PLINT temp1 ;
14784 int res1 = SWIG_TMPOBJ ;
14785 octave_value_list _out;
14786 octave_value_list *_outp=&_out;
14787 octave_value _outv;
14788
14789 arg1 = &temp1;
14790 if (!SWIG_check_num_args("plgcompression",args.length(),0,0,0)) {
14791 SWIG_fail;
14792 }
14793 plgcompression(arg1);
14794 _outv = octave_value();
14795 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14796 if (SWIG_IsTmpObj(res1)) {
14797 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
14798 } else {
14799 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14800 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
14801 }
14802 fail:
14803 return _out;
14804 }
14805
14806
14807 SWIG_DEFUN( plgdev, _wrap_plgdev, _wrap_plgdev_texinfo ) {
14808 char *arg1 = (char *) 0 ;
14809 octave_value_list retval1 ;
14810 octave_value_list _out;
14811 octave_value_list *_outp=&_out;
14812 octave_value _outv;
14813
14814 {
14815 // Check if version >= 3.4.0
14816 # if OCTAVE_API_VERSION_NUMBER < 45
14817 retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
14818 # else
14819 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
14820 # endif
14821 arg1 = (char *) retval1( 0 ).char_matrix_value().data();
14822 }
14823 if (!SWIG_check_num_args("plgdev",args.length(),0,0,0)) {
14824 SWIG_fail;
14825 }
14826 plgdev(arg1);
14827 _outv = octave_value();
14828 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14829 {
14830 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
14831 }
14832 fail:
14833 return _out;
14834 }
14835
14836
14837 SWIG_DEFUN( plgdidev, _wrap_plgdidev, _wrap_plgdidev_texinfo ) {
14838 PLFLT *arg1 = (PLFLT *) 0 ;
14839 PLFLT *arg2 = (PLFLT *) 0 ;
14840 PLFLT *arg3 = (PLFLT *) 0 ;
14841 PLFLT *arg4 = (PLFLT *) 0 ;
14842 PLFLT temp1 ;
14843 int res1 = SWIG_TMPOBJ ;
14844 PLFLT temp2 ;
14845 int res2 = SWIG_TMPOBJ ;
14846 PLFLT temp3 ;
14847 int res3 = SWIG_TMPOBJ ;
14848 PLFLT temp4 ;
14849 int res4 = SWIG_TMPOBJ ;
14850 octave_value_list _out;
14851 octave_value_list *_outp=&_out;
14852 octave_value _outv;
14853
14854 arg1 = &temp1;
14855 arg2 = &temp2;
14856 arg3 = &temp3;
14857 arg4 = &temp4;
14858 if (!SWIG_check_num_args("plgdidev",args.length(),0,0,0)) {
14859 SWIG_fail;
14860 }
14861 plgdidev(arg1,arg2,arg3,arg4);
14862 _outv = octave_value();
14863 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14864 if (SWIG_IsTmpObj(res1)) {
14865 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14866 } else {
14867 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14868 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14869 }
14870 if (SWIG_IsTmpObj(res2)) {
14871 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
14872 } else {
14873 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14874 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
14875 }
14876 if (SWIG_IsTmpObj(res3)) {
14877 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
14878 } else {
14879 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14880 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
14881 }
14882 if (SWIG_IsTmpObj(res4)) {
14883 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
14884 } else {
14885 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14886 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14887 }
14888 fail:
14889 return _out;
14890 }
14891
14892
14893 SWIG_DEFUN( plgdiori, _wrap_plgdiori, _wrap_plgdiori_texinfo ) {
14894 PLFLT *arg1 = (PLFLT *) 0 ;
14895 PLFLT temp1 ;
14896 int res1 = SWIG_TMPOBJ ;
14897 octave_value_list _out;
14898 octave_value_list *_outp=&_out;
14899 octave_value _outv;
14900
14901 arg1 = &temp1;
14902 if (!SWIG_check_num_args("plgdiori",args.length(),0,0,0)) {
14903 SWIG_fail;
14904 }
14905 plgdiori(arg1);
14906 _outv = octave_value();
14907 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14908 if (SWIG_IsTmpObj(res1)) {
14909 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14910 } else {
14911 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14912 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14913 }
14914 fail:
14915 return _out;
14916 }
14917
14918
14919 SWIG_DEFUN( plgdiplt, _wrap_plgdiplt, _wrap_plgdiplt_texinfo ) {
14920 PLFLT *arg1 = (PLFLT *) 0 ;
14921 PLFLT *arg2 = (PLFLT *) 0 ;
14922 PLFLT *arg3 = (PLFLT *) 0 ;
14923 PLFLT *arg4 = (PLFLT *) 0 ;
14924 PLFLT temp1 ;
14925 int res1 = SWIG_TMPOBJ ;
14926 PLFLT temp2 ;
14927 int res2 = SWIG_TMPOBJ ;
14928 PLFLT temp3 ;
14929 int res3 = SWIG_TMPOBJ ;
14930 PLFLT temp4 ;
14931 int res4 = SWIG_TMPOBJ ;
14932 octave_value_list _out;
14933 octave_value_list *_outp=&_out;
14934 octave_value _outv;
14935
14936 arg1 = &temp1;
14937 arg2 = &temp2;
14938 arg3 = &temp3;
14939 arg4 = &temp4;
14940 if (!SWIG_check_num_args("plgdiplt",args.length(),0,0,0)) {
14941 SWIG_fail;
14942 }
14943 plgdiplt(arg1,arg2,arg3,arg4);
14944 _outv = octave_value();
14945 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14946 if (SWIG_IsTmpObj(res1)) {
14947 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
14948 } else {
14949 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14950 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
14951 }
14952 if (SWIG_IsTmpObj(res2)) {
14953 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
14954 } else {
14955 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14956 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
14957 }
14958 if (SWIG_IsTmpObj(res3)) {
14959 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
14960 } else {
14961 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14962 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
14963 }
14964 if (SWIG_IsTmpObj(res4)) {
14965 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
14966 } else {
14967 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14968 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
14969 }
14970 fail:
14971 return _out;
14972 }
14973
14974
14975 SWIG_DEFUN( plgfam, _wrap_plgfam, _wrap_plgfam_texinfo ) {
14976 PLINT *arg1 = (PLINT *) 0 ;
14977 PLINT *arg2 = (PLINT *) 0 ;
14978 PLINT *arg3 = (PLINT *) 0 ;
14979 PLINT temp1 ;
14980 int res1 = SWIG_TMPOBJ ;
14981 PLINT temp2 ;
14982 int res2 = SWIG_TMPOBJ ;
14983 PLINT temp3 ;
14984 int res3 = SWIG_TMPOBJ ;
14985 octave_value_list _out;
14986 octave_value_list *_outp=&_out;
14987 octave_value _outv;
14988
14989 arg1 = &temp1;
14990 arg2 = &temp2;
14991 arg3 = &temp3;
14992 if (!SWIG_check_num_args("plgfam",args.length(),0,0,0)) {
14993 SWIG_fail;
14994 }
14995 plgfam(arg1,arg2,arg3);
14996 _outv = octave_value();
14997 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
14998 if (SWIG_IsTmpObj(res1)) {
14999 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15000 } else {
15001 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15002 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15003 }
15004 if (SWIG_IsTmpObj(res2)) {
15005 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15006 } else {
15007 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15008 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15009 }
15010 if (SWIG_IsTmpObj(res3)) {
15011 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15012 } else {
15013 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15014 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15015 }
15016 fail:
15017 return _out;
15018 }
15019
15020
15021 SWIG_DEFUN( plgfci, _wrap_plgfci, _wrap_plgfci_texinfo ) {
15022 PLUNICODE *arg1 = (PLUNICODE *) 0 ;
15023 PLUNICODE temp1 ;
15024 int res1 = SWIG_TMPOBJ ;
15025 octave_value_list _out;
15026 octave_value_list *_outp=&_out;
15027 octave_value _outv;
15028
15029 arg1 = &temp1;
15030 if (!SWIG_check_num_args("plgfci",args.length(),0,0,0)) {
15031 SWIG_fail;
15032 }
15033 plgfci(arg1);
15034 _outv = octave_value();
15035 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15036 if (SWIG_IsTmpObj(res1)) {
15037 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_unsigned_SS_int((*arg1)));
15038 } else {
15039 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15040 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_unsigned_int, new_flags));
15041 }
15042 fail:
15043 return _out;
15044 }
15045
15046
15047 SWIG_DEFUN( plgfnam, _wrap_plgfnam, _wrap_plgfnam_texinfo ) {
15048 char *arg1 = (char *) 0 ;
15049 octave_value_list retval1 ;
15050 octave_value_list _out;
15051 octave_value_list *_outp=&_out;
15052 octave_value _outv;
15053
15054 {
15055 // Check if version >= 3.4.0
15056 # if OCTAVE_API_VERSION_NUMBER < 45
15057 retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
15058 # else
15059 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15060 # endif
15061 arg1 = (char *) retval1( 0 ).char_matrix_value().data();
15062 }
15063 if (!SWIG_check_num_args("plgfnam",args.length(),0,0,0)) {
15064 SWIG_fail;
15065 }
15066 plgfnam(arg1);
15067 _outv = octave_value();
15068 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15069 {
15070 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
15071 }
15072 fail:
15073 return _out;
15074 }
15075
15076
15077 SWIG_DEFUN( plgfont, _wrap_plgfont, _wrap_plgfont_texinfo ) {
15078 PLINT *arg1 = (PLINT *) 0 ;
15079 PLINT *arg2 = (PLINT *) 0 ;
15080 PLINT *arg3 = (PLINT *) 0 ;
15081 PLINT temp1 ;
15082 int res1 = SWIG_TMPOBJ ;
15083 PLINT temp2 ;
15084 int res2 = SWIG_TMPOBJ ;
15085 PLINT temp3 ;
15086 int res3 = SWIG_TMPOBJ ;
15087 octave_value_list _out;
15088 octave_value_list *_outp=&_out;
15089 octave_value _outv;
15090
15091 arg1 = &temp1;
15092 arg2 = &temp2;
15093 arg3 = &temp3;
15094 if (!SWIG_check_num_args("plgfont",args.length(),0,0,0)) {
15095 SWIG_fail;
15096 }
15097 plgfont(arg1,arg2,arg3);
15098 _outv = octave_value();
15099 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15100 if (SWIG_IsTmpObj(res1)) {
15101 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15102 } else {
15103 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15104 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15105 }
15106 if (SWIG_IsTmpObj(res2)) {
15107 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15108 } else {
15109 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15110 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15111 }
15112 if (SWIG_IsTmpObj(res3)) {
15113 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15114 } else {
15115 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15116 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15117 }
15118 fail:
15119 return _out;
15120 }
15121
15122
15123 SWIG_DEFUN( plglevel, _wrap_plglevel, _wrap_plglevel_texinfo ) {
15124 PLINT *arg1 = (PLINT *) 0 ;
15125 PLINT temp1 ;
15126 int res1 = SWIG_TMPOBJ ;
15127 octave_value_list _out;
15128 octave_value_list *_outp=&_out;
15129 octave_value _outv;
15130
15131 arg1 = &temp1;
15132 if (!SWIG_check_num_args("plglevel",args.length(),0,0,0)) {
15133 SWIG_fail;
15134 }
15135 plglevel(arg1);
15136 _outv = octave_value();
15137 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15138 if (SWIG_IsTmpObj(res1)) {
15139 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15140 } else {
15141 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15142 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15143 }
15144 fail:
15145 return _out;
15146 }
15147
15148
15149 SWIG_DEFUN( plgpage, _wrap_plgpage, _wrap_plgpage_texinfo ) {
15150 PLFLT *arg1 = (PLFLT *) 0 ;
15151 PLFLT *arg2 = (PLFLT *) 0 ;
15152 PLINT *arg3 = (PLINT *) 0 ;
15153 PLINT *arg4 = (PLINT *) 0 ;
15154 PLINT *arg5 = (PLINT *) 0 ;
15155 PLINT *arg6 = (PLINT *) 0 ;
15156 PLFLT temp1 ;
15157 int res1 = SWIG_TMPOBJ ;
15158 PLFLT temp2 ;
15159 int res2 = SWIG_TMPOBJ ;
15160 PLINT temp3 ;
15161 int res3 = SWIG_TMPOBJ ;
15162 PLINT temp4 ;
15163 int res4 = SWIG_TMPOBJ ;
15164 PLINT temp5 ;
15165 int res5 = SWIG_TMPOBJ ;
15166 PLINT temp6 ;
15167 int res6 = SWIG_TMPOBJ ;
15168 octave_value_list _out;
15169 octave_value_list *_outp=&_out;
15170 octave_value _outv;
15171
15172 arg1 = &temp1;
15173 arg2 = &temp2;
15174 arg3 = &temp3;
15175 arg4 = &temp4;
15176 arg5 = &temp5;
15177 arg6 = &temp6;
15178 if (!SWIG_check_num_args("plgpage",args.length(),0,0,0)) {
15179 SWIG_fail;
15180 }
15181 plgpage(arg1,arg2,arg3,arg4,arg5,arg6);
15182 _outv = octave_value();
15183 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15184 if (SWIG_IsTmpObj(res1)) {
15185 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15186 } else {
15187 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15188 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15189 }
15190 if (SWIG_IsTmpObj(res2)) {
15191 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15192 } else {
15193 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15194 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15195 }
15196 if (SWIG_IsTmpObj(res3)) {
15197 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg3)));
15198 } else {
15199 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15200 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
15201 }
15202 if (SWIG_IsTmpObj(res4)) {
15203 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg4)));
15204 } else {
15205 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15206 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
15207 }
15208 if (SWIG_IsTmpObj(res5)) {
15209 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg5)));
15210 } else {
15211 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15212 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
15213 }
15214 if (SWIG_IsTmpObj(res6)) {
15215 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg6)));
15216 } else {
15217 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15218 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
15219 }
15220 fail:
15221 return _out;
15222 }
15223
15224
15225 SWIG_DEFUN( plgra, _wrap_plgra, _wrap_plgra_texinfo ) {
15226 octave_value_list _out;
15227 octave_value_list *_outp=&_out;
15228 octave_value _outv;
15229
15230 if (!SWIG_check_num_args("plgra",args.length(),0,0,0)) {
15231 SWIG_fail;
15232 }
15233 plgra();
15234 _outv = octave_value();
15235 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15236 fail:
15237 return _out;
15238 }
15239
15240
15241 SWIG_DEFUN( plgspa, _wrap_plgspa, _wrap_plgspa_texinfo ) {
15242 PLFLT *arg1 = (PLFLT *) 0 ;
15243 PLFLT *arg2 = (PLFLT *) 0 ;
15244 PLFLT *arg3 = (PLFLT *) 0 ;
15245 PLFLT *arg4 = (PLFLT *) 0 ;
15246 PLFLT temp1 ;
15247 int res1 = SWIG_TMPOBJ ;
15248 PLFLT temp2 ;
15249 int res2 = SWIG_TMPOBJ ;
15250 PLFLT temp3 ;
15251 int res3 = SWIG_TMPOBJ ;
15252 PLFLT temp4 ;
15253 int res4 = SWIG_TMPOBJ ;
15254 octave_value_list _out;
15255 octave_value_list *_outp=&_out;
15256 octave_value _outv;
15257
15258 arg1 = &temp1;
15259 arg2 = &temp2;
15260 arg3 = &temp3;
15261 arg4 = &temp4;
15262 if (!SWIG_check_num_args("plgspa",args.length(),0,0,0)) {
15263 SWIG_fail;
15264 }
15265 plgspa(arg1,arg2,arg3,arg4);
15266 _outv = octave_value();
15267 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15268 if (SWIG_IsTmpObj(res1)) {
15269 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15270 } else {
15271 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15272 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15273 }
15274 if (SWIG_IsTmpObj(res2)) {
15275 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15276 } else {
15277 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15278 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15279 }
15280 if (SWIG_IsTmpObj(res3)) {
15281 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15282 } else {
15283 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15284 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15285 }
15286 if (SWIG_IsTmpObj(res4)) {
15287 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15288 } else {
15289 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15290 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15291 }
15292 fail:
15293 return _out;
15294 }
15295
15296
15297 SWIG_DEFUN( plgstrm, _wrap_plgstrm, _wrap_plgstrm_texinfo ) {
15298 PLINT *arg1 = (PLINT *) 0 ;
15299 PLINT temp1 ;
15300 int res1 = SWIG_TMPOBJ ;
15301 octave_value_list _out;
15302 octave_value_list *_outp=&_out;
15303 octave_value _outv;
15304
15305 arg1 = &temp1;
15306 if (!SWIG_check_num_args("plgstrm",args.length(),0,0,0)) {
15307 SWIG_fail;
15308 }
15309 plgstrm(arg1);
15310 _outv = octave_value();
15311 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15312 if (SWIG_IsTmpObj(res1)) {
15313 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15314 } else {
15315 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15316 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15317 }
15318 fail:
15319 return _out;
15320 }
15321
15322
15323 SWIG_DEFUN( plgver, _wrap_plgver, _wrap_plgver_texinfo ) {
15324 char *arg1 = (char *) 0 ;
15325 octave_value_list retval1 ;
15326 octave_value_list _out;
15327 octave_value_list *_outp=&_out;
15328 octave_value _outv;
15329
15330 {
15331 // Check if version >= 3.4.0
15332 # if OCTAVE_API_VERSION_NUMBER < 45
15333 retval1( 0 ) = octave_value( charMatrix( 80, 1 ), true );
15334 # else
15335 retval1( 0 ) = octave_value( charMatrix( 80, 1 ) );
15336 # endif
15337 arg1 = (char *) retval1( 0 ).char_matrix_value().data();
15338 }
15339 if (!SWIG_check_num_args("plgver",args.length(),0,0,0)) {
15340 SWIG_fail;
15341 }
15342 plgver(arg1);
15343 _outv = octave_value();
15344 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15345 {
15346 _outp = SWIG_Octave_AppendOutput( _outp, retval1( 0 ) );
15347 }
15348 fail:
15349 return _out;
15350 }
15351
15352
15353 SWIG_DEFUN( plgvpd, _wrap_plgvpd, _wrap_plgvpd_texinfo ) {
15354 PLFLT *arg1 = (PLFLT *) 0 ;
15355 PLFLT *arg2 = (PLFLT *) 0 ;
15356 PLFLT *arg3 = (PLFLT *) 0 ;
15357 PLFLT *arg4 = (PLFLT *) 0 ;
15358 PLFLT temp1 ;
15359 int res1 = SWIG_TMPOBJ ;
15360 PLFLT temp2 ;
15361 int res2 = SWIG_TMPOBJ ;
15362 PLFLT temp3 ;
15363 int res3 = SWIG_TMPOBJ ;
15364 PLFLT temp4 ;
15365 int res4 = SWIG_TMPOBJ ;
15366 octave_value_list _out;
15367 octave_value_list *_outp=&_out;
15368 octave_value _outv;
15369
15370 arg1 = &temp1;
15371 arg2 = &temp2;
15372 arg3 = &temp3;
15373 arg4 = &temp4;
15374 if (!SWIG_check_num_args("plgvpd",args.length(),0,0,0)) {
15375 SWIG_fail;
15376 }
15377 plgvpd(arg1,arg2,arg3,arg4);
15378 _outv = octave_value();
15379 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15380 if (SWIG_IsTmpObj(res1)) {
15381 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15382 } else {
15383 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15384 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15385 }
15386 if (SWIG_IsTmpObj(res2)) {
15387 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15388 } else {
15389 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15390 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15391 }
15392 if (SWIG_IsTmpObj(res3)) {
15393 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15394 } else {
15395 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15396 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15397 }
15398 if (SWIG_IsTmpObj(res4)) {
15399 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15400 } else {
15401 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15402 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15403 }
15404 fail:
15405 return _out;
15406 }
15407
15408
15409 SWIG_DEFUN( plgvpw, _wrap_plgvpw, _wrap_plgvpw_texinfo ) {
15410 PLFLT *arg1 = (PLFLT *) 0 ;
15411 PLFLT *arg2 = (PLFLT *) 0 ;
15412 PLFLT *arg3 = (PLFLT *) 0 ;
15413 PLFLT *arg4 = (PLFLT *) 0 ;
15414 PLFLT temp1 ;
15415 int res1 = SWIG_TMPOBJ ;
15416 PLFLT temp2 ;
15417 int res2 = SWIG_TMPOBJ ;
15418 PLFLT temp3 ;
15419 int res3 = SWIG_TMPOBJ ;
15420 PLFLT temp4 ;
15421 int res4 = SWIG_TMPOBJ ;
15422 octave_value_list _out;
15423 octave_value_list *_outp=&_out;
15424 octave_value _outv;
15425
15426 arg1 = &temp1;
15427 arg2 = &temp2;
15428 arg3 = &temp3;
15429 arg4 = &temp4;
15430 if (!SWIG_check_num_args("plgvpw",args.length(),0,0,0)) {
15431 SWIG_fail;
15432 }
15433 plgvpw(arg1,arg2,arg3,arg4);
15434 _outv = octave_value();
15435 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15436 if (SWIG_IsTmpObj(res1)) {
15437 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
15438 } else {
15439 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15440 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
15441 }
15442 if (SWIG_IsTmpObj(res2)) {
15443 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
15444 } else {
15445 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15446 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
15447 }
15448 if (SWIG_IsTmpObj(res3)) {
15449 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg3)));
15450 } else {
15451 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15452 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_double, new_flags));
15453 }
15454 if (SWIG_IsTmpObj(res4)) {
15455 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15456 } else {
15457 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15458 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15459 }
15460 fail:
15461 return _out;
15462 }
15463
15464
15465 SWIG_DEFUN( plgxax, _wrap_plgxax, _wrap_plgxax_texinfo ) {
15466 PLINT *arg1 = (PLINT *) 0 ;
15467 PLINT *arg2 = (PLINT *) 0 ;
15468 PLINT temp1 ;
15469 int res1 = SWIG_TMPOBJ ;
15470 PLINT temp2 ;
15471 int res2 = SWIG_TMPOBJ ;
15472 octave_value_list _out;
15473 octave_value_list *_outp=&_out;
15474 octave_value _outv;
15475
15476 arg1 = &temp1;
15477 arg2 = &temp2;
15478 if (!SWIG_check_num_args("plgxax",args.length(),0,0,0)) {
15479 SWIG_fail;
15480 }
15481 plgxax(arg1,arg2);
15482 _outv = octave_value();
15483 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15484 if (SWIG_IsTmpObj(res1)) {
15485 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15486 } else {
15487 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15488 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15489 }
15490 if (SWIG_IsTmpObj(res2)) {
15491 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15492 } else {
15493 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15494 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15495 }
15496 fail:
15497 return _out;
15498 }
15499
15500
15501 SWIG_DEFUN( plgyax, _wrap_plgyax, _wrap_plgyax_texinfo ) {
15502 PLINT *arg1 = (PLINT *) 0 ;
15503 PLINT *arg2 = (PLINT *) 0 ;
15504 PLINT temp1 ;
15505 int res1 = SWIG_TMPOBJ ;
15506 PLINT temp2 ;
15507 int res2 = SWIG_TMPOBJ ;
15508 octave_value_list _out;
15509 octave_value_list *_outp=&_out;
15510 octave_value _outv;
15511
15512 arg1 = &temp1;
15513 arg2 = &temp2;
15514 if (!SWIG_check_num_args("plgyax",args.length(),0,0,0)) {
15515 SWIG_fail;
15516 }
15517 plgyax(arg1,arg2);
15518 _outv = octave_value();
15519 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15520 if (SWIG_IsTmpObj(res1)) {
15521 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15522 } else {
15523 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15524 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15525 }
15526 if (SWIG_IsTmpObj(res2)) {
15527 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15528 } else {
15529 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15530 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15531 }
15532 fail:
15533 return _out;
15534 }
15535
15536
15537 SWIG_DEFUN( plgzax, _wrap_plgzax, _wrap_plgzax_texinfo ) {
15538 PLINT *arg1 = (PLINT *) 0 ;
15539 PLINT *arg2 = (PLINT *) 0 ;
15540 PLINT temp1 ;
15541 int res1 = SWIG_TMPOBJ ;
15542 PLINT temp2 ;
15543 int res2 = SWIG_TMPOBJ ;
15544 octave_value_list _out;
15545 octave_value_list *_outp=&_out;
15546 octave_value _outv;
15547
15548 arg1 = &temp1;
15549 arg2 = &temp2;
15550 if (!SWIG_check_num_args("plgzax",args.length(),0,0,0)) {
15551 SWIG_fail;
15552 }
15553 plgzax(arg1,arg2);
15554 _outv = octave_value();
15555 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15556 if (SWIG_IsTmpObj(res1)) {
15557 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
15558 } else {
15559 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15560 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
15561 }
15562 if (SWIG_IsTmpObj(res2)) {
15563 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
15564 } else {
15565 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15566 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
15567 }
15568 fail:
15569 return _out;
15570 }
15571
15572
15573 SWIG_DEFUN( plhist, _wrap_plhist, _wrap_plhist_texinfo ) {
15574 PLINT arg1 ;
15575 PLFLT *arg2 = (PLFLT *) 0 ;
15576 PLFLT arg3 ;
15577 PLFLT arg4 ;
15578 PLINT arg5 ;
15579 PLINT arg6 ;
15580 Matrix temp1 ;
15581 double val3 ;
15582 int ecode3 = 0 ;
15583 double val4 ;
15584 int ecode4 = 0 ;
15585 int val5 ;
15586 int ecode5 = 0 ;
15587 int val6 ;
15588 int ecode6 = 0 ;
15589 octave_value_list _out;
15590 octave_value_list *_outp=&_out;
15591 octave_value _outv;
15592
15593 if (!SWIG_check_num_args("plhist",args.length(),5,5,0)) {
15594 SWIG_fail;
15595 }
15596 {
15597 if ( _n_dims( args(0) ) > 1 )
15598 {
15599 error( "argument must be a scalar or vector" ); SWIG_fail;
15600 }
15601 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
15602 temp1 = args(0).matrix_value();
15603 arg2 = &temp1( 0, 0 );
15604 }
15605 ecode3 = SWIG_AsVal_double(args(1), &val3);
15606 if (!SWIG_IsOK(ecode3)) {
15607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhist" "', argument " "3"" of type '" "PLFLT""'");
15608 }
15609 arg3 = (PLFLT)(val3);
15610 ecode4 = SWIG_AsVal_double(args(2), &val4);
15611 if (!SWIG_IsOK(ecode4)) {
15612 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plhist" "', argument " "4"" of type '" "PLFLT""'");
15613 }
15614 arg4 = (PLFLT)(val4);
15615 ecode5 = SWIG_AsVal_int(args(3), &val5);
15616 if (!SWIG_IsOK(ecode5)) {
15617 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plhist" "', argument " "5"" of type '" "PLINT""'");
15618 }
15619 arg5 = (PLINT)(val5);
15620 ecode6 = SWIG_AsVal_int(args(4), &val6);
15621 if (!SWIG_IsOK(ecode6)) {
15622 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plhist" "', argument " "6"" of type '" "PLINT""'");
15623 }
15624 arg6 = (PLINT)(val6);
15625 plhist(arg1,(double const *)arg2,arg3,arg4,arg5,arg6);
15626 _outv = octave_value();
15627 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15628 {
15629
15630 }
15631 fail:
15632 return _out;
15633 }
15634
15635
15636 SWIG_DEFUN( plhlsrgb, _wrap_plhlsrgb, _wrap_plhlsrgb_texinfo ) {
15637 PLFLT arg1 ;
15638 PLFLT arg2 ;
15639 PLFLT arg3 ;
15640 PLFLT *arg4 = (PLFLT *) 0 ;
15641 PLFLT *arg5 = (PLFLT *) 0 ;
15642 PLFLT *arg6 = (PLFLT *) 0 ;
15643 double val1 ;
15644 int ecode1 = 0 ;
15645 double val2 ;
15646 int ecode2 = 0 ;
15647 double val3 ;
15648 int ecode3 = 0 ;
15649 PLFLT temp4 ;
15650 int res4 = SWIG_TMPOBJ ;
15651 PLFLT temp5 ;
15652 int res5 = SWIG_TMPOBJ ;
15653 PLFLT temp6 ;
15654 int res6 = SWIG_TMPOBJ ;
15655 octave_value_list _out;
15656 octave_value_list *_outp=&_out;
15657 octave_value _outv;
15658
15659 arg4 = &temp4;
15660 arg5 = &temp5;
15661 arg6 = &temp6;
15662 if (!SWIG_check_num_args("plhlsrgb",args.length(),3,3,0)) {
15663 SWIG_fail;
15664 }
15665 ecode1 = SWIG_AsVal_double(args(0), &val1);
15666 if (!SWIG_IsOK(ecode1)) {
15667 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plhlsrgb" "', argument " "1"" of type '" "PLFLT""'");
15668 }
15669 arg1 = (PLFLT)(val1);
15670 ecode2 = SWIG_AsVal_double(args(1), &val2);
15671 if (!SWIG_IsOK(ecode2)) {
15672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plhlsrgb" "', argument " "2"" of type '" "PLFLT""'");
15673 }
15674 arg2 = (PLFLT)(val2);
15675 ecode3 = SWIG_AsVal_double(args(2), &val3);
15676 if (!SWIG_IsOK(ecode3)) {
15677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plhlsrgb" "', argument " "3"" of type '" "PLFLT""'");
15678 }
15679 arg3 = (PLFLT)(val3);
15680 plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);
15681 _outv = octave_value();
15682 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15683 if (SWIG_IsTmpObj(res4)) {
15684 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
15685 } else {
15686 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15687 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
15688 }
15689 if (SWIG_IsTmpObj(res5)) {
15690 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
15691 } else {
15692 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15693 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
15694 }
15695 if (SWIG_IsTmpObj(res6)) {
15696 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
15697 } else {
15698 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15699 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
15700 }
15701 fail:
15702 return _out;
15703 }
15704
15705
15706 SWIG_DEFUN( plinit, _wrap_plinit, _wrap_plinit_texinfo ) {
15707 octave_value_list _out;
15708 octave_value_list *_outp=&_out;
15709 octave_value _outv;
15710
15711 if (!SWIG_check_num_args("plinit",args.length(),0,0,0)) {
15712 SWIG_fail;
15713 }
15714 plinit();
15715 _outv = octave_value();
15716 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15717 fail:
15718 return _out;
15719 }
15720
15721
15722 SWIG_DEFUN( pljoin, _wrap_pljoin, _wrap_pljoin_texinfo ) {
15723 PLFLT arg1 ;
15724 PLFLT arg2 ;
15725 PLFLT arg3 ;
15726 PLFLT arg4 ;
15727 double val1 ;
15728 int ecode1 = 0 ;
15729 double val2 ;
15730 int ecode2 = 0 ;
15731 double val3 ;
15732 int ecode3 = 0 ;
15733 double val4 ;
15734 int ecode4 = 0 ;
15735 octave_value_list _out;
15736 octave_value_list *_outp=&_out;
15737 octave_value _outv;
15738
15739 if (!SWIG_check_num_args("pljoin",args.length(),4,4,0)) {
15740 SWIG_fail;
15741 }
15742 ecode1 = SWIG_AsVal_double(args(0), &val1);
15743 if (!SWIG_IsOK(ecode1)) {
15744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pljoin" "', argument " "1"" of type '" "PLFLT""'");
15745 }
15746 arg1 = (PLFLT)(val1);
15747 ecode2 = SWIG_AsVal_double(args(1), &val2);
15748 if (!SWIG_IsOK(ecode2)) {
15749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pljoin" "', argument " "2"" of type '" "PLFLT""'");
15750 }
15751 arg2 = (PLFLT)(val2);
15752 ecode3 = SWIG_AsVal_double(args(2), &val3);
15753 if (!SWIG_IsOK(ecode3)) {
15754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pljoin" "', argument " "3"" of type '" "PLFLT""'");
15755 }
15756 arg3 = (PLFLT)(val3);
15757 ecode4 = SWIG_AsVal_double(args(3), &val4);
15758 if (!SWIG_IsOK(ecode4)) {
15759 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pljoin" "', argument " "4"" of type '" "PLFLT""'");
15760 }
15761 arg4 = (PLFLT)(val4);
15762 pljoin(arg1,arg2,arg3,arg4);
15763 _outv = octave_value();
15764 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15765 fail:
15766 return _out;
15767 }
15768
15769
15770 SWIG_DEFUN( pllab, _wrap_pllab, _wrap_pllab_texinfo ) {
15771 char *arg1 = (char *) 0 ;
15772 char *arg2 = (char *) 0 ;
15773 char *arg3 = (char *) 0 ;
15774 int res1 ;
15775 char *buf1 = 0 ;
15776 int alloc1 = 0 ;
15777 int res2 ;
15778 char *buf2 = 0 ;
15779 int alloc2 = 0 ;
15780 int res3 ;
15781 char *buf3 = 0 ;
15782 int alloc3 = 0 ;
15783 octave_value_list _out;
15784 octave_value_list *_outp=&_out;
15785 octave_value _outv;
15786
15787 if (!SWIG_check_num_args("pllab",args.length(),3,3,0)) {
15788 SWIG_fail;
15789 }
15790 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
15791 if (!SWIG_IsOK(res1)) {
15792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pllab" "', argument " "1"" of type '" "char const *""'");
15793 }
15794 arg1 = (char *)(buf1);
15795 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
15796 if (!SWIG_IsOK(res2)) {
15797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pllab" "', argument " "2"" of type '" "char const *""'");
15798 }
15799 arg2 = (char *)(buf2);
15800 res3 = SWIG_AsCharPtrAndSize(args(2), &buf3, NULL, &alloc3);
15801 if (!SWIG_IsOK(res3)) {
15802 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pllab" "', argument " "3"" of type '" "char const *""'");
15803 }
15804 arg3 = (char *)(buf3);
15805 pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);
15806 _outv = octave_value();
15807 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
15808 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
15809 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
15810 if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
15811 fail:
15812 return _out;
15813 }
15814
15815
15816 SWIG_DEFUN( pllegend, _wrap_pllegend, _wrap_pllegend_texinfo ) {
15817 PLFLT *arg1 = (PLFLT *) 0 ;
15818 PLFLT *arg2 = (PLFLT *) 0 ;
15819 PLINT arg3 ;
15820 PLINT arg4 ;
15821 PLFLT arg5 ;
15822 PLFLT arg6 ;
15823 PLFLT arg7 ;
15824 PLINT arg8 ;
15825 PLINT arg9 ;
15826 PLINT arg10 ;
15827 PLINT arg11 ;
15828 PLINT arg12 ;
15829 PLINT arg13 ;
15830 PLINT *arg14 = (PLINT *) 0 ;
15831 PLFLT arg15 ;
15832 PLFLT arg16 ;
15833 PLFLT arg17 ;
15834 PLFLT arg18 ;
15835 PLINT *arg19 = (PLINT *) 0 ;
15836 char **arg20 = (char **) 0 ;
15837 PLINT *arg21 = (PLINT *) 0 ;
15838 PLINT *arg22 = (PLINT *) 0 ;
15839 PLFLT *arg23 = (PLFLT *) 0 ;
15840 PLFLT *arg24 = (PLFLT *) 0 ;
15841 PLINT *arg25 = (PLINT *) 0 ;
15842 PLINT *arg26 = (PLINT *) 0 ;
15843 PLFLT *arg27 = (PLFLT *) 0 ;
15844 PLINT *arg28 = (PLINT *) 0 ;
15845 PLFLT *arg29 = (PLFLT *) 0 ;
15846 PLINT *arg30 = (PLINT *) 0 ;
15847 char **arg31 = (char **) 0 ;
15848 PLFLT temp1 ;
15849 int res1 = SWIG_TMPOBJ ;
15850 PLFLT temp2 ;
15851 int res2 = SWIG_TMPOBJ ;
15852 int val3 ;
15853 int ecode3 = 0 ;
15854 int val4 ;
15855 int ecode4 = 0 ;
15856 double val5 ;
15857 int ecode5 = 0 ;
15858 double val6 ;
15859 int ecode6 = 0 ;
15860 double val7 ;
15861 int ecode7 = 0 ;
15862 int val8 ;
15863 int ecode8 = 0 ;
15864 int val9 ;
15865 int ecode9 = 0 ;
15866 int val10 ;
15867 int ecode10 = 0 ;
15868 int val11 ;
15869 int ecode11 = 0 ;
15870 int val12 ;
15871 int ecode12 = 0 ;
15872 Matrix temp13 ;
15873 double val15 ;
15874 int ecode15 = 0 ;
15875 double val16 ;
15876 int ecode16 = 0 ;
15877 double val17 ;
15878 int ecode17 = 0 ;
15879 double val18 ;
15880 int ecode18 = 0 ;
15881 Matrix temp19 ;
15882 Matrix temp21 ;
15883 Matrix temp22 ;
15884 Matrix temp23 ;
15885 Matrix temp24 ;
15886 Matrix temp25 ;
15887 Matrix temp26 ;
15888 Matrix temp27 ;
15889 Matrix temp28 ;
15890 Matrix temp29 ;
15891 Matrix temp30 ;
15892 octave_value_list _out;
15893 octave_value_list *_outp=&_out;
15894 octave_value _outv;
15895
15896 arg1 = &temp1;
15897 arg2 = &temp2;
15898 if (!SWIG_check_num_args("pllegend",args.length(),28,28,0)) {
15899 SWIG_fail;
15900 }
15901 ecode3 = SWIG_AsVal_int(args(0), &val3);
15902 if (!SWIG_IsOK(ecode3)) {
15903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllegend" "', argument " "3"" of type '" "PLINT""'");
15904 }
15905 arg3 = (PLINT)(val3);
15906 ecode4 = SWIG_AsVal_int(args(1), &val4);
15907 if (!SWIG_IsOK(ecode4)) {
15908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pllegend" "', argument " "4"" of type '" "PLINT""'");
15909 }
15910 arg4 = (PLINT)(val4);
15911 ecode5 = SWIG_AsVal_double(args(2), &val5);
15912 if (!SWIG_IsOK(ecode5)) {
15913 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pllegend" "', argument " "5"" of type '" "PLFLT""'");
15914 }
15915 arg5 = (PLFLT)(val5);
15916 ecode6 = SWIG_AsVal_double(args(3), &val6);
15917 if (!SWIG_IsOK(ecode6)) {
15918 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pllegend" "', argument " "6"" of type '" "PLFLT""'");
15919 }
15920 arg6 = (PLFLT)(val6);
15921 ecode7 = SWIG_AsVal_double(args(4), &val7);
15922 if (!SWIG_IsOK(ecode7)) {
15923 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pllegend" "', argument " "7"" of type '" "PLFLT""'");
15924 }
15925 arg7 = (PLFLT)(val7);
15926 ecode8 = SWIG_AsVal_int(args(5), &val8);
15927 if (!SWIG_IsOK(ecode8)) {
15928 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pllegend" "', argument " "8"" of type '" "PLINT""'");
15929 }
15930 arg8 = (PLINT)(val8);
15931 ecode9 = SWIG_AsVal_int(args(6), &val9);
15932 if (!SWIG_IsOK(ecode9)) {
15933 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pllegend" "', argument " "9"" of type '" "PLINT""'");
15934 }
15935 arg9 = (PLINT)(val9);
15936 ecode10 = SWIG_AsVal_int(args(7), &val10);
15937 if (!SWIG_IsOK(ecode10)) {
15938 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "pllegend" "', argument " "10"" of type '" "PLINT""'");
15939 }
15940 arg10 = (PLINT)(val10);
15941 ecode11 = SWIG_AsVal_int(args(8), &val11);
15942 if (!SWIG_IsOK(ecode11)) {
15943 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pllegend" "', argument " "11"" of type '" "PLINT""'");
15944 }
15945 arg11 = (PLINT)(val11);
15946 ecode12 = SWIG_AsVal_int(args(9), &val12);
15947 if (!SWIG_IsOK(ecode12)) {
15948 SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "pllegend" "', argument " "12"" of type '" "PLINT""'");
15949 }
15950 arg12 = (PLINT)(val12);
15951 {
15952 if ( _n_dims( args(10) ) > 1 )
15953 {
15954 error( "argument must be a scalar or vector" ); SWIG_fail;
15955 }
15956 arg13 = Alen = (PLINT) ( _dim( args(10), 0 ) );
15957 arg14 = new PLINT[Alen];
15958 temp13 = args(10).matrix_value();
15959 _cvt_double_to( arg14, &temp13( 0, 0 ), Alen );
15960 }
15961 ecode15 = SWIG_AsVal_double(args(11), &val15);
15962 if (!SWIG_IsOK(ecode15)) {
15963 SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "pllegend" "', argument " "15"" of type '" "PLFLT""'");
15964 }
15965 arg15 = (PLFLT)(val15);
15966 ecode16 = SWIG_AsVal_double(args(12), &val16);
15967 if (!SWIG_IsOK(ecode16)) {
15968 SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "pllegend" "', argument " "16"" of type '" "PLFLT""'");
15969 }
15970 arg16 = (PLFLT)(val16);
15971 ecode17 = SWIG_AsVal_double(args(13), &val17);
15972 if (!SWIG_IsOK(ecode17)) {
15973 SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "pllegend" "', argument " "17"" of type '" "PLFLT""'");
15974 }
15975 arg17 = (PLFLT)(val17);
15976 ecode18 = SWIG_AsVal_double(args(14), &val18);
15977 if (!SWIG_IsOK(ecode18)) {
15978 SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "pllegend" "', argument " "18"" of type '" "PLFLT""'");
15979 }
15980 arg18 = (PLFLT)(val18);
15981 {
15982 if ( _n_dims( args(15) ) > 1 )
15983 {
15984 error( "argument must be a scalar or vector" ); SWIG_fail;
15985 }
15986 if ( _dim( args(15), 0 ) != Alen )
15987 {
15988 error( "argument vectors must be same length" ); SWIG_fail;
15989 }
15990 temp19 = args(15).matrix_value();
15991 arg19 = new PLINT[Alen];
15992 _cvt_double_to( arg19, &temp19( 0, 0 ), Alen );
15993 }
15994 {
15995 charMatrix temp_matrix;
15996 Cell temp_cell;
15997 char *tmp_cstring;
15998 std::string str;
15999 size_t max_length = 0, non_blank_length;
16000 int i, ifcell;
16001 if ( _n_dims( args(16) ) > 2 )
16002 {
16003 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
16004 }
16005 if ( !args(16).is_empty() )
16006 {
16007 if ( _dim( args(16), 0 ) != Alen )
16008 {
16009 error( "first dimension must be same length as previous vector" ); SWIG_fail;
16010 }
16011 arg20 = new char*[Alen];
16012 ifcell = args(16).is_cell();
16013 if ( ifcell )
16014 {
16015 temp_cell = args(16).cell_value();
16016 }
16017 else
16018 {
16019 temp_matrix = args(16).char_matrix_value();
16020 // Allow one extra space for null termination.
16021 max_length = _dim( args(16), 1 ) + 1;
16022 }
16023
16024 for ( i = 0; i < Alen; i++ )
16025 {
16026 // Must copy string to "permanent" location because the string
16027 // location corresponding to tmp_cstring gets
16028 // overwritten for each iteration of loop.
16029 if ( ifcell )
16030 {
16031 if ( temp_cell.elem( i ).is_string() )
16032 {
16033 str = temp_cell.elem( i ).string_value();
16034 // leave room for null termination.
16035 max_length = str.size() + 1;
16036 tmp_cstring = (char *) str.c_str();
16037 }
16038 else
16039 {
16040 // Use null string if user attempts to pass a cell array
16041 // with a non-string element (likely an empty element
16042 // since that should be allowed by the PLplot interface
16043 // if that element is going to be unused).
16044 // leave room for null termination.
16045 max_length = 1;
16046 tmp_cstring = (char *) "";
16047 }
16048 }
16049 else
16050 {
16051 tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
16052 }
16053 arg20[i] = new char[max_length];
16054 strncpy( arg20[i], tmp_cstring, max_length - 1 );
16055 arg20[i][max_length - 1] = '\0';
16056 // All the trailing blank crapola should not be needed for
16057 // string cell arrays.
16058 if ( !ifcell )
16059 {
16060 // remove trailing-blank padding that is used by the
16061 // charMatrix class to insure all strings in a given
16062 // charMatrix instance have the same length.
16063 // This transformation also removes legitimate trailing
16064 // blanks but there is nothing we can do about that
16065 // for the charMatrix class.
16066
16067 // Look for trailing nulls first (just in case, although that
16068 // shouldn't happen if charMatrix implemented as documented)
16069 // before looking for trailing blanks.
16070 non_blank_length = max_length - 2;
16071 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == '\0' )
16072 {
16073 non_blank_length--;
16074 }
16075 while ( non_blank_length >= 0 && arg20[i][non_blank_length] == ' ' )
16076 {
16077 non_blank_length--;
16078 }
16079 arg20[i][non_blank_length + 1] = '\0';
16080 }
16081 }
16082 }
16083 else
16084 {
16085 arg20 = NULL;
16086 }
16087 }
16088 {
16089 if ( _n_dims( args(17) ) > 1 )
16090 {
16091 error( "argument must be a scalar or vector" ); SWIG_fail;
16092 }
16093 if ( !args(17).is_empty() )
16094 {
16095 if ( _dim( args(17), 0 ) != Alen )
16096 {
16097 error( "argument vectors must be same length" ); SWIG_fail;
16098 }
16099 temp21 = args(17).matrix_value();
16100 arg21 = new PLINT[Alen];
16101 _cvt_double_to( arg21, &temp21( 0, 0 ), Alen );
16102 }
16103 else
16104 {
16105 arg21 = NULL;
16106 }
16107 }
16108 {
16109 if ( _n_dims( args(18) ) > 1 )
16110 {
16111 error( "argument must be a scalar or vector" ); SWIG_fail;
16112 }
16113 if ( !args(18).is_empty() )
16114 {
16115 if ( _dim( args(18), 0 ) != Alen )
16116 {
16117 error( "argument vectors must be same length" ); SWIG_fail;
16118 }
16119 temp22 = args(18).matrix_value();
16120 arg22 = new PLINT[Alen];
16121 _cvt_double_to( arg22, &temp22( 0, 0 ), Alen );
16122 }
16123 else
16124 {
16125 arg22 = NULL;
16126 }
16127 }
16128 {
16129 if ( _n_dims( args(19) ) > 1 )
16130 {
16131 error( "argument must be a scalar or vector" ); SWIG_fail;
16132 }
16133 if ( !args(19).is_empty() )
16134 {
16135 if ( _dim( args(19), 0 ) != Alen )
16136 {
16137 error( "argument vectors must be same length" ); SWIG_fail;
16138 }
16139 temp23 = args(19).matrix_value();
16140 arg23 = &temp23( 0, 0 );
16141 }
16142 else
16143 {
16144 arg23 = NULL;
16145 }
16146 }
16147 {
16148 if ( _n_dims( args(20) ) > 1 )
16149 {
16150 error( "argument must be a scalar or vector" ); SWIG_fail;
16151 }
16152 if ( !args(20).is_empty() )
16153 {
16154 if ( _dim( args(20), 0 ) != Alen )
16155 {
16156 error( "argument vectors must be same length" ); SWIG_fail;
16157 }
16158 temp24 = args(20).matrix_value();
16159 arg24 = &temp24( 0, 0 );
16160 }
16161 else
16162 {
16163 arg24 = NULL;
16164 }
16165 }
16166 {
16167 if ( _n_dims( args(21) ) > 1 )
16168 {
16169 error( "argument must be a scalar or vector" ); SWIG_fail;
16170 }
16171 if ( !args(21).is_empty() )
16172 {
16173 if ( _dim( args(21), 0 ) != Alen )
16174 {
16175 error( "argument vectors must be same length" ); SWIG_fail;
16176 }
16177 temp25 = args(21).matrix_value();
16178 arg25 = new PLINT[Alen];
16179 _cvt_double_to( arg25, &temp25( 0, 0 ), Alen );
16180 }
16181 else
16182 {
16183 arg25 = NULL;
16184 }
16185 }
16186 {
16187 if ( _n_dims( args(22) ) > 1 )
16188 {
16189 error( "argument must be a scalar or vector" ); SWIG_fail;
16190 }
16191 if ( !args(22).is_empty() )
16192 {
16193 if ( _dim( args(22), 0 ) != Alen )
16194 {
16195 error( "argument vectors must be same length" ); SWIG_fail;
16196 }
16197 temp26 = args(22).matrix_value();
16198 arg26 = new PLINT[Alen];
16199 _cvt_double_to( arg26, &temp26( 0, 0 ), Alen );
16200 }
16201 else
16202 {
16203 arg26 = NULL;
16204 }
16205 }
16206 {
16207 if ( _n_dims( args(23) ) > 1 )
16208 {
16209 error( "argument must be a scalar or vector" ); SWIG_fail;
16210 }
16211 if ( !args(23).is_empty() )
16212 {
16213 if ( _dim( args(23), 0 ) != Alen )
16214 {
16215 error( "argument vectors must be same length" ); SWIG_fail;
16216 }
16217 temp27 = args(23).matrix_value();
16218 arg27 = &temp27( 0, 0 );
16219 }
16220 else
16221 {
16222 arg27 = NULL;
16223 }
16224 }
16225 {
16226 if ( _n_dims( args(24) ) > 1 )
16227 {
16228 error( "argument must be a scalar or vector" ); SWIG_fail;
16229 }
16230 if ( !args(24).is_empty() )
16231 {
16232 if ( _dim( args(24), 0 ) != Alen )
16233 {
16234 error( "argument vectors must be same length" ); SWIG_fail;
16235 }
16236 temp28 = args(24).matrix_value();
16237 arg28 = new PLINT[Alen];
16238 _cvt_double_to( arg28, &temp28( 0, 0 ), Alen );
16239 }
16240 else
16241 {
16242 arg28 = NULL;
16243 }
16244 }
16245 {
16246 if ( _n_dims( args(25) ) > 1 )
16247 {
16248 error( "argument must be a scalar or vector" ); SWIG_fail;
16249 }
16250 if ( !args(25).is_empty() )
16251 {
16252 if ( _dim( args(25), 0 ) != Alen )
16253 {
16254 error( "argument vectors must be same length" ); SWIG_fail;
16255 }
16256 temp29 = args(25).matrix_value();
16257 arg29 = &temp29( 0, 0 );
16258 }
16259 else
16260 {
16261 arg29 = NULL;
16262 }
16263 }
16264 {
16265 if ( _n_dims( args(26) ) > 1 )
16266 {
16267 error( "argument must be a scalar or vector" ); SWIG_fail;
16268 }
16269 if ( !args(26).is_empty() )
16270 {
16271 if ( _dim( args(26), 0 ) != Alen )
16272 {
16273 error( "argument vectors must be same length" ); SWIG_fail;
16274 }
16275 temp30 = args(26).matrix_value();
16276 arg30 = new PLINT[Alen];
16277 _cvt_double_to( arg30, &temp30( 0, 0 ), Alen );
16278 }
16279 else
16280 {
16281 arg30 = NULL;
16282 }
16283 }
16284 {
16285 charMatrix temp_matrix;
16286 Cell temp_cell;
16287 char *tmp_cstring;
16288 std::string str;
16289 size_t max_length = 0, non_blank_length;
16290 int i, ifcell;
16291 if ( _n_dims( args(27) ) > 2 )
16292 {
16293 error( "argument must be a scalar or vector or matrix" ); SWIG_fail;
16294 }
16295 if ( !args(27).is_empty() )
16296 {
16297 if ( _dim( args(27), 0 ) != Alen )
16298 {
16299 error( "first dimension must be same length as previous vector" ); SWIG_fail;
16300 }
16301 arg31 = new char*[Alen];
16302 ifcell = args(27).is_cell();
16303 if ( ifcell )
16304 {
16305 temp_cell = args(27).cell_value();
16306 }
16307 else
16308 {
16309 temp_matrix = args(27).char_matrix_value();
16310 // Allow one extra space for null termination.
16311 max_length = _dim( args(27), 1 ) + 1;
16312 }
16313
16314 for ( i = 0; i < Alen; i++ )
16315 {
16316 // Must copy string to "permanent" location because the string
16317 // location corresponding to tmp_cstring gets
16318 // overwritten for each iteration of loop.
16319 if ( ifcell )
16320 {
16321 if ( temp_cell.elem( i ).is_string() )
16322 {
16323 str = temp_cell.elem( i ).string_value();
16324 // leave room for null termination.
16325 max_length = str.size() + 1;
16326 tmp_cstring = (char *) str.c_str();
16327 }
16328 else
16329 {
16330 // Use null string if user attempts to pass a cell array
16331 // with a non-string element (likely an empty element
16332 // since that should be allowed by the PLplot interface
16333 // if that element is going to be unused).
16334 // leave room for null termination.
16335 max_length = 1;
16336 tmp_cstring = (char *) "";
16337 }
16338 }
16339 else
16340 {
16341 tmp_cstring = (char *) temp_matrix.row_as_string( i ).c_str();
16342 }
16343 arg31[i] = new char[max_length];
16344 strncpy( arg31[i], tmp_cstring, max_length - 1 );
16345 arg31[i][max_length - 1] = '\0';
16346 // All the trailing blank crapola should not be needed for
16347 // string cell arrays.
16348 if ( !ifcell )
16349 {
16350 // remove trailing-blank padding that is used by the
16351 // charMatrix class to insure all strings in a given
16352 // charMatrix instance have the same length.
16353 // This transformation also removes legitimate trailing
16354 // blanks but there is nothing we can do about that
16355 // for the charMatrix class.
16356
16357 // Look for trailing nulls first (just in case, although that
16358 // shouldn't happen if charMatrix implemented as documented)
16359 // before looking for trailing blanks.
16360 non_blank_length = max_length - 2;
16361 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == '\0' )
16362 {
16363 non_blank_length--;
16364 }
16365 while ( non_blank_length >= 0 && arg31[i][non_blank_length] == ' ' )
16366 {
16367 non_blank_length--;
16368 }
16369 arg31[i][non_blank_length + 1] = '\0';
16370 }
16371 }
16372 }
16373 else
16374 {
16375 arg31 = NULL;
16376 }
16377 }
16378 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);
16379 _outv = octave_value();
16380 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16381 if (SWIG_IsTmpObj(res1)) {
16382 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
16383 } else {
16384 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16385 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
16386 }
16387 if (SWIG_IsTmpObj(res2)) {
16388 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
16389 } else {
16390 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16391 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
16392 }
16393 {
16394 delete [] arg14;
16395 }
16396 {
16397 delete [] arg19;
16398 }
16399 {
16400 int i;
16401 if ( arg20 != NULL )
16402 {
16403 for ( i = 0; i < Alen; i++ )
16404 {
16405 delete[] arg20[i];
16406 }
16407 delete[] arg20;
16408 }
16409 }
16410 {
16411 if ( arg21 != NULL )
16412 delete [] arg21;
16413 }
16414 {
16415 if ( arg22 != NULL )
16416 delete [] arg22;
16417 }
16418 {
16419
16420 }
16421 {
16422
16423 }
16424 {
16425 if ( arg25 != NULL )
16426 delete [] arg25;
16427 }
16428 {
16429 if ( arg26 != NULL )
16430 delete [] arg26;
16431 }
16432 {
16433
16434 }
16435 {
16436 if ( arg28 != NULL )
16437 delete [] arg28;
16438 }
16439 {
16440
16441 }
16442 {
16443 if ( arg30 != NULL )
16444 delete [] arg30;
16445 }
16446 {
16447 int i;
16448 if ( arg31 != NULL )
16449 {
16450 for ( i = 0; i < Alen; i++ )
16451 {
16452 delete[] arg31[i];
16453 }
16454 delete[] arg31;
16455 }
16456 }
16457 fail:
16458 return _out;
16459 }
16460
16461
16462 SWIG_DEFUN( pllightsource, _wrap_pllightsource, _wrap_pllightsource_texinfo ) {
16463 PLFLT arg1 ;
16464 PLFLT arg2 ;
16465 PLFLT arg3 ;
16466 double val1 ;
16467 int ecode1 = 0 ;
16468 double val2 ;
16469 int ecode2 = 0 ;
16470 double val3 ;
16471 int ecode3 = 0 ;
16472 octave_value_list _out;
16473 octave_value_list *_outp=&_out;
16474 octave_value _outv;
16475
16476 if (!SWIG_check_num_args("pllightsource",args.length(),3,3,0)) {
16477 SWIG_fail;
16478 }
16479 ecode1 = SWIG_AsVal_double(args(0), &val1);
16480 if (!SWIG_IsOK(ecode1)) {
16481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllightsource" "', argument " "1"" of type '" "PLFLT""'");
16482 }
16483 arg1 = (PLFLT)(val1);
16484 ecode2 = SWIG_AsVal_double(args(1), &val2);
16485 if (!SWIG_IsOK(ecode2)) {
16486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pllightsource" "', argument " "2"" of type '" "PLFLT""'");
16487 }
16488 arg2 = (PLFLT)(val2);
16489 ecode3 = SWIG_AsVal_double(args(2), &val3);
16490 if (!SWIG_IsOK(ecode3)) {
16491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pllightsource" "', argument " "3"" of type '" "PLFLT""'");
16492 }
16493 arg3 = (PLFLT)(val3);
16494 pllightsource(arg1,arg2,arg3);
16495 _outv = octave_value();
16496 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16497 fail:
16498 return _out;
16499 }
16500
16501
16502 SWIG_DEFUN( plline, _wrap_plline, _wrap_plline_texinfo ) {
16503 PLINT arg1 ;
16504 PLFLT *arg2 = (PLFLT *) 0 ;
16505 PLFLT *arg3 = (PLFLT *) 0 ;
16506 Matrix temp1 ;
16507 Matrix temp3 ;
16508 octave_value_list _out;
16509 octave_value_list *_outp=&_out;
16510 octave_value _outv;
16511
16512 if (!SWIG_check_num_args("plline",args.length(),2,2,0)) {
16513 SWIG_fail;
16514 }
16515 {
16516 if ( _n_dims( args(0) ) > 1 )
16517 {
16518 error( "argument must be a scalar or vector" ); SWIG_fail;
16519 }
16520 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16521 temp1 = args(0).matrix_value();
16522 arg2 = &temp1( 0, 0 );
16523 }
16524 {
16525 if ( _n_dims( args(1) ) > 1 )
16526 {
16527 error( "argument must be a scalar or vector" ); SWIG_fail;
16528 }
16529 if ( _dim( args(1), 0 ) != Alen )
16530 {
16531 error( "argument vectors must be same length" ); SWIG_fail;
16532 }
16533 temp3 = args(1).matrix_value();
16534 arg3 = &temp3( 0, 0 );
16535 }
16536 plline(arg1,(double const *)arg2,(double const *)arg3);
16537 _outv = octave_value();
16538 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16539 {
16540
16541 }
16542 {
16543
16544 }
16545 fail:
16546 return _out;
16547 }
16548
16549
16550 SWIG_DEFUN( plline3, _wrap_plline3, _wrap_plline3_texinfo ) {
16551 PLINT arg1 ;
16552 PLFLT *arg2 = (PLFLT *) 0 ;
16553 PLFLT *arg3 = (PLFLT *) 0 ;
16554 PLFLT *arg4 = (PLFLT *) 0 ;
16555 Matrix temp1 ;
16556 Matrix temp3 ;
16557 Matrix temp4 ;
16558 octave_value_list _out;
16559 octave_value_list *_outp=&_out;
16560 octave_value _outv;
16561
16562 if (!SWIG_check_num_args("plline3",args.length(),3,3,0)) {
16563 SWIG_fail;
16564 }
16565 {
16566 if ( _n_dims( args(0) ) > 1 )
16567 {
16568 error( "argument must be a scalar or vector" ); SWIG_fail;
16569 }
16570 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16571 temp1 = args(0).matrix_value();
16572 arg2 = &temp1( 0, 0 );
16573 }
16574 {
16575 if ( _n_dims( args(1) ) > 1 )
16576 {
16577 error( "argument must be a scalar or vector" ); SWIG_fail;
16578 }
16579 if ( _dim( args(1), 0 ) != Alen )
16580 {
16581 error( "argument vectors must be same length" ); SWIG_fail;
16582 }
16583 temp3 = args(1).matrix_value();
16584 arg3 = &temp3( 0, 0 );
16585 }
16586 {
16587 if ( _n_dims( args(2) ) > 1 )
16588 {
16589 error( "argument must be a scalar or vector" ); SWIG_fail;
16590 }
16591 if ( _dim( args(2), 0 ) != Alen )
16592 {
16593 error( "argument vectors must be same length" ); SWIG_fail;
16594 }
16595 temp4 = args(2).matrix_value();
16596 arg4 = &temp4( 0, 0 );
16597 }
16598 plline3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4);
16599 _outv = octave_value();
16600 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16601 {
16602
16603 }
16604 {
16605
16606 }
16607 {
16608
16609 }
16610 fail:
16611 return _out;
16612 }
16613
16614
16615 SWIG_DEFUN( pllsty, _wrap_pllsty, _wrap_pllsty_texinfo ) {
16616 PLINT arg1 ;
16617 int val1 ;
16618 int ecode1 = 0 ;
16619 octave_value_list _out;
16620 octave_value_list *_outp=&_out;
16621 octave_value _outv;
16622
16623 if (!SWIG_check_num_args("pllsty",args.length(),1,1,0)) {
16624 SWIG_fail;
16625 }
16626 ecode1 = SWIG_AsVal_int(args(0), &val1);
16627 if (!SWIG_IsOK(ecode1)) {
16628 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pllsty" "', argument " "1"" of type '" "PLINT""'");
16629 }
16630 arg1 = (PLINT)(val1);
16631 pllsty(arg1);
16632 _outv = octave_value();
16633 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16634 fail:
16635 return _out;
16636 }
16637
16638
16639 SWIG_DEFUN( plmkstrm, _wrap_plmkstrm, _wrap_plmkstrm_texinfo ) {
16640 PLINT *arg1 = (PLINT *) 0 ;
16641 PLINT temp1 ;
16642 int res1 = SWIG_TMPOBJ ;
16643 octave_value_list _out;
16644 octave_value_list *_outp=&_out;
16645 octave_value _outv;
16646
16647 arg1 = &temp1;
16648 if (!SWIG_check_num_args("plmkstrm",args.length(),0,0,0)) {
16649 SWIG_fail;
16650 }
16651 plmkstrm(arg1);
16652 _outv = octave_value();
16653 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16654 if (SWIG_IsTmpObj(res1)) {
16655 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg1)));
16656 } else {
16657 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16658 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags));
16659 }
16660 fail:
16661 return _out;
16662 }
16663
16664
16665 SWIG_DEFUN( plmtex, _wrap_plmtex, _wrap_plmtex_texinfo ) {
16666 char *arg1 = (char *) 0 ;
16667 PLFLT arg2 ;
16668 PLFLT arg3 ;
16669 PLFLT arg4 ;
16670 char *arg5 = (char *) 0 ;
16671 int res1 ;
16672 char *buf1 = 0 ;
16673 int alloc1 = 0 ;
16674 double val2 ;
16675 int ecode2 = 0 ;
16676 double val3 ;
16677 int ecode3 = 0 ;
16678 double val4 ;
16679 int ecode4 = 0 ;
16680 int res5 ;
16681 char *buf5 = 0 ;
16682 int alloc5 = 0 ;
16683 octave_value_list _out;
16684 octave_value_list *_outp=&_out;
16685 octave_value _outv;
16686
16687 if (!SWIG_check_num_args("plmtex",args.length(),5,5,0)) {
16688 SWIG_fail;
16689 }
16690 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16691 if (!SWIG_IsOK(res1)) {
16692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex" "', argument " "1"" of type '" "char const *""'");
16693 }
16694 arg1 = (char *)(buf1);
16695 ecode2 = SWIG_AsVal_double(args(1), &val2);
16696 if (!SWIG_IsOK(ecode2)) {
16697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex" "', argument " "2"" of type '" "PLFLT""'");
16698 }
16699 arg2 = (PLFLT)(val2);
16700 ecode3 = SWIG_AsVal_double(args(2), &val3);
16701 if (!SWIG_IsOK(ecode3)) {
16702 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex" "', argument " "3"" of type '" "PLFLT""'");
16703 }
16704 arg3 = (PLFLT)(val3);
16705 ecode4 = SWIG_AsVal_double(args(3), &val4);
16706 if (!SWIG_IsOK(ecode4)) {
16707 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex" "', argument " "4"" of type '" "PLFLT""'");
16708 }
16709 arg4 = (PLFLT)(val4);
16710 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
16711 if (!SWIG_IsOK(res5)) {
16712 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex" "', argument " "5"" of type '" "char const *""'");
16713 }
16714 arg5 = (char *)(buf5);
16715 plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
16716 _outv = octave_value();
16717 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16718 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16719 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16720 fail:
16721 return _out;
16722 }
16723
16724
16725 SWIG_DEFUN( plmtex3, _wrap_plmtex3, _wrap_plmtex3_texinfo ) {
16726 char *arg1 = (char *) 0 ;
16727 PLFLT arg2 ;
16728 PLFLT arg3 ;
16729 PLFLT arg4 ;
16730 char *arg5 = (char *) 0 ;
16731 int res1 ;
16732 char *buf1 = 0 ;
16733 int alloc1 = 0 ;
16734 double val2 ;
16735 int ecode2 = 0 ;
16736 double val3 ;
16737 int ecode3 = 0 ;
16738 double val4 ;
16739 int ecode4 = 0 ;
16740 int res5 ;
16741 char *buf5 = 0 ;
16742 int alloc5 = 0 ;
16743 octave_value_list _out;
16744 octave_value_list *_outp=&_out;
16745 octave_value _outv;
16746
16747 if (!SWIG_check_num_args("plmtex3",args.length(),5,5,0)) {
16748 SWIG_fail;
16749 }
16750 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
16751 if (!SWIG_IsOK(res1)) {
16752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plmtex3" "', argument " "1"" of type '" "char const *""'");
16753 }
16754 arg1 = (char *)(buf1);
16755 ecode2 = SWIG_AsVal_double(args(1), &val2);
16756 if (!SWIG_IsOK(ecode2)) {
16757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmtex3" "', argument " "2"" of type '" "PLFLT""'");
16758 }
16759 arg2 = (PLFLT)(val2);
16760 ecode3 = SWIG_AsVal_double(args(2), &val3);
16761 if (!SWIG_IsOK(ecode3)) {
16762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmtex3" "', argument " "3"" of type '" "PLFLT""'");
16763 }
16764 arg3 = (PLFLT)(val3);
16765 ecode4 = SWIG_AsVal_double(args(3), &val4);
16766 if (!SWIG_IsOK(ecode4)) {
16767 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmtex3" "', argument " "4"" of type '" "PLFLT""'");
16768 }
16769 arg4 = (PLFLT)(val4);
16770 res5 = SWIG_AsCharPtrAndSize(args(4), &buf5, NULL, &alloc5);
16771 if (!SWIG_IsOK(res5)) {
16772 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plmtex3" "', argument " "5"" of type '" "char const *""'");
16773 }
16774 arg5 = (char *)(buf5);
16775 plmtex3((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);
16776 _outv = octave_value();
16777 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16778 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
16779 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
16780 fail:
16781 return _out;
16782 }
16783
16784
16785 SWIG_DEFUN( plparseopts, _wrap_plparseopts, _wrap_plparseopts_texinfo ) {
16786 int *arg1 = (int *) 0 ;
16787 char **arg2 = (char **) 0 ;
16788 PLINT arg3 ;
16789 void *argp1 = 0 ;
16790 int res1 = 0 ;
16791 void *argp2 = 0 ;
16792 int res2 = 0 ;
16793 int val3 ;
16794 int ecode3 = 0 ;
16795 octave_value_list _out;
16796 octave_value_list *_outp=&_out;
16797 octave_value _outv;
16798 PLINT result;
16799
16800 if (!SWIG_check_num_args("plparseopts",args.length(),3,3,0)) {
16801 SWIG_fail;
16802 }
16803 res1 = SWIG_ConvertPtr(args(0), &argp1,SWIGTYPE_p_int, 0 | 0 );
16804 if (!SWIG_IsOK(res1)) {
16805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plparseopts" "', argument " "1"" of type '" "int *""'");
16806 }
16807 arg1 = (int *)(argp1);
16808 res2 = SWIG_ConvertPtr(args(1), &argp2,SWIGTYPE_p_p_char, 0 | 0 );
16809 if (!SWIG_IsOK(res2)) {
16810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plparseopts" "', argument " "2"" of type '" "char const **""'");
16811 }
16812 arg2 = (char **)(argp2);
16813 ecode3 = SWIG_AsVal_int(args(2), &val3);
16814 if (!SWIG_IsOK(ecode3)) {
16815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plparseopts" "', argument " "3"" of type '" "PLINT""'");
16816 }
16817 arg3 = (PLINT)(val3);
16818 result = (PLINT)plparseopts(arg1,(char const **)arg2,arg3);
16819 _outv = SWIG_From_int((int)(result));
16820 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16821 fail:
16822 return _out;
16823 }
16824
16825
16826 SWIG_DEFUN( plpat, _wrap_plpat, _wrap_plpat_texinfo ) {
16827 PLINT arg1 ;
16828 PLINT *arg2 = (PLINT *) 0 ;
16829 PLINT *arg3 = (PLINT *) 0 ;
16830 Matrix temp1 ;
16831 Matrix temp3 ;
16832 octave_value_list _out;
16833 octave_value_list *_outp=&_out;
16834 octave_value _outv;
16835
16836 if (!SWIG_check_num_args("plpat",args.length(),2,2,0)) {
16837 SWIG_fail;
16838 }
16839 {
16840 if ( _n_dims( args(0) ) > 1 )
16841 {
16842 error( "argument must be a scalar or vector" ); SWIG_fail;
16843 }
16844 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16845 arg2 = new PLINT[Alen];
16846 temp1 = args(0).matrix_value();
16847 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
16848 }
16849 {
16850 if ( _n_dims( args(1) ) > 1 )
16851 {
16852 error( "argument must be a scalar or vector" ); SWIG_fail;
16853 }
16854 if ( _dim( args(1), 0 ) != Alen )
16855 {
16856 error( "argument vectors must be same length" ); SWIG_fail;
16857 }
16858 temp3 = args(1).matrix_value();
16859 arg3 = new PLINT[Alen];
16860 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
16861 }
16862 plpat(arg1,(int const *)arg2,(int const *)arg3);
16863 _outv = octave_value();
16864 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16865 {
16866 delete [] arg2;
16867 }
16868 {
16869 delete [] arg3;
16870 }
16871 fail:
16872 return _out;
16873 }
16874
16875
16876 SWIG_DEFUN( plpath, _wrap_plpath, _wrap_plpath_texinfo ) {
16877 PLINT arg1 ;
16878 PLFLT arg2 ;
16879 PLFLT arg3 ;
16880 PLFLT arg4 ;
16881 PLFLT arg5 ;
16882 int val1 ;
16883 int ecode1 = 0 ;
16884 double val2 ;
16885 int ecode2 = 0 ;
16886 double val3 ;
16887 int ecode3 = 0 ;
16888 double val4 ;
16889 int ecode4 = 0 ;
16890 double val5 ;
16891 int ecode5 = 0 ;
16892 octave_value_list _out;
16893 octave_value_list *_outp=&_out;
16894 octave_value _outv;
16895
16896 if (!SWIG_check_num_args("plpath",args.length(),5,5,0)) {
16897 SWIG_fail;
16898 }
16899 ecode1 = SWIG_AsVal_int(args(0), &val1);
16900 if (!SWIG_IsOK(ecode1)) {
16901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpath" "', argument " "1"" of type '" "PLINT""'");
16902 }
16903 arg1 = (PLINT)(val1);
16904 ecode2 = SWIG_AsVal_double(args(1), &val2);
16905 if (!SWIG_IsOK(ecode2)) {
16906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plpath" "', argument " "2"" of type '" "PLFLT""'");
16907 }
16908 arg2 = (PLFLT)(val2);
16909 ecode3 = SWIG_AsVal_double(args(2), &val3);
16910 if (!SWIG_IsOK(ecode3)) {
16911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plpath" "', argument " "3"" of type '" "PLFLT""'");
16912 }
16913 arg3 = (PLFLT)(val3);
16914 ecode4 = SWIG_AsVal_double(args(3), &val4);
16915 if (!SWIG_IsOK(ecode4)) {
16916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpath" "', argument " "4"" of type '" "PLFLT""'");
16917 }
16918 arg4 = (PLFLT)(val4);
16919 ecode5 = SWIG_AsVal_double(args(4), &val5);
16920 if (!SWIG_IsOK(ecode5)) {
16921 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpath" "', argument " "5"" of type '" "PLFLT""'");
16922 }
16923 arg5 = (PLFLT)(val5);
16924 plpath(arg1,arg2,arg3,arg4,arg5);
16925 _outv = octave_value();
16926 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16927 fail:
16928 return _out;
16929 }
16930
16931
16932 SWIG_DEFUN( plpoin, _wrap_plpoin, _wrap_plpoin_texinfo ) {
16933 PLINT arg1 ;
16934 PLFLT *arg2 = (PLFLT *) 0 ;
16935 PLFLT *arg3 = (PLFLT *) 0 ;
16936 PLINT arg4 ;
16937 Matrix temp1 ;
16938 Matrix temp3 ;
16939 int val4 ;
16940 int ecode4 = 0 ;
16941 octave_value_list _out;
16942 octave_value_list *_outp=&_out;
16943 octave_value _outv;
16944
16945 if (!SWIG_check_num_args("plpoin",args.length(),3,3,0)) {
16946 SWIG_fail;
16947 }
16948 {
16949 if ( _n_dims( args(0) ) > 1 )
16950 {
16951 error( "argument must be a scalar or vector" ); SWIG_fail;
16952 }
16953 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
16954 temp1 = args(0).matrix_value();
16955 arg2 = &temp1( 0, 0 );
16956 }
16957 {
16958 if ( _n_dims( args(1) ) > 1 )
16959 {
16960 error( "argument must be a scalar or vector" ); SWIG_fail;
16961 }
16962 if ( _dim( args(1), 0 ) != Alen )
16963 {
16964 error( "argument vectors must be same length" ); SWIG_fail;
16965 }
16966 temp3 = args(1).matrix_value();
16967 arg3 = &temp3( 0, 0 );
16968 }
16969 ecode4 = SWIG_AsVal_int(args(2), &val4);
16970 if (!SWIG_IsOK(ecode4)) {
16971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plpoin" "', argument " "4"" of type '" "PLINT""'");
16972 }
16973 arg4 = (PLINT)(val4);
16974 plpoin(arg1,(double const *)arg2,(double const *)arg3,arg4);
16975 _outv = octave_value();
16976 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
16977 {
16978
16979 }
16980 {
16981
16982 }
16983 fail:
16984 return _out;
16985 }
16986
16987
16988 SWIG_DEFUN( plpoin3, _wrap_plpoin3, _wrap_plpoin3_texinfo ) {
16989 PLINT arg1 ;
16990 PLFLT *arg2 = (PLFLT *) 0 ;
16991 PLFLT *arg3 = (PLFLT *) 0 ;
16992 PLFLT *arg4 = (PLFLT *) 0 ;
16993 PLINT arg5 ;
16994 Matrix temp1 ;
16995 Matrix temp3 ;
16996 Matrix temp4 ;
16997 int val5 ;
16998 int ecode5 = 0 ;
16999 octave_value_list _out;
17000 octave_value_list *_outp=&_out;
17001 octave_value _outv;
17002
17003 if (!SWIG_check_num_args("plpoin3",args.length(),4,4,0)) {
17004 SWIG_fail;
17005 }
17006 {
17007 if ( _n_dims( args(0) ) > 1 )
17008 {
17009 error( "argument must be a scalar or vector" ); SWIG_fail;
17010 }
17011 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17012 temp1 = args(0).matrix_value();
17013 arg2 = &temp1( 0, 0 );
17014 }
17015 {
17016 if ( _n_dims( args(1) ) > 1 )
17017 {
17018 error( "argument must be a scalar or vector" ); SWIG_fail;
17019 }
17020 if ( _dim( args(1), 0 ) != Alen )
17021 {
17022 error( "argument vectors must be same length" ); SWIG_fail;
17023 }
17024 temp3 = args(1).matrix_value();
17025 arg3 = &temp3( 0, 0 );
17026 }
17027 {
17028 if ( _n_dims( args(2) ) > 1 )
17029 {
17030 error( "argument must be a scalar or vector" ); SWIG_fail;
17031 }
17032 if ( _dim( args(2), 0 ) != Alen )
17033 {
17034 error( "argument vectors must be same length" ); SWIG_fail;
17035 }
17036 temp4 = args(2).matrix_value();
17037 arg4 = &temp4( 0, 0 );
17038 }
17039 ecode5 = SWIG_AsVal_int(args(3), &val5);
17040 if (!SWIG_IsOK(ecode5)) {
17041 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plpoin3" "', argument " "5"" of type '" "PLINT""'");
17042 }
17043 arg5 = (PLINT)(val5);
17044 plpoin3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,arg5);
17045 _outv = octave_value();
17046 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17047 {
17048
17049 }
17050 {
17051
17052 }
17053 {
17054
17055 }
17056 fail:
17057 return _out;
17058 }
17059
17060
17061 SWIG_DEFUN( plpoly3, _wrap_plpoly3, _wrap_plpoly3_texinfo ) {
17062 PLINT arg1 ;
17063 PLFLT *arg2 = (PLFLT *) 0 ;
17064 PLFLT *arg3 = (PLFLT *) 0 ;
17065 PLFLT *arg4 = (PLFLT *) 0 ;
17066 PLBOOL *arg5 = (PLBOOL *) 0 ;
17067 PLBOOL arg6 ;
17068 Matrix temp1 ;
17069 Matrix temp3 ;
17070 Matrix temp4 ;
17071 Matrix temp5 ;
17072 int val6 ;
17073 int ecode6 = 0 ;
17074 octave_value_list _out;
17075 octave_value_list *_outp=&_out;
17076 octave_value _outv;
17077
17078 if (!SWIG_check_num_args("plpoly3",args.length(),5,5,0)) {
17079 SWIG_fail;
17080 }
17081 {
17082 if ( _n_dims( args(0) ) > 1 )
17083 {
17084 error( "argument must be a scalar or vector" ); SWIG_fail;
17085 }
17086 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
17087 temp1 = args(0).matrix_value();
17088 arg2 = &temp1( 0, 0 );
17089 }
17090 {
17091 if ( _n_dims( args(1) ) > 1 )
17092 {
17093 error( "argument must be a scalar or vector" ); SWIG_fail;
17094 }
17095 if ( _dim( args(1), 0 ) != Alen )
17096 {
17097 error( "argument vectors must be same length" ); SWIG_fail;
17098 }
17099 temp3 = args(1).matrix_value();
17100 arg3 = &temp3( 0, 0 );
17101 }
17102 {
17103 if ( _n_dims( args(2) ) > 1 )
17104 {
17105 error( "argument must be a scalar or vector" ); SWIG_fail;
17106 }
17107 if ( _dim( args(2), 0 ) != Alen )
17108 {
17109 error( "argument vectors must be same length" ); SWIG_fail;
17110 }
17111 temp4 = args(2).matrix_value();
17112 arg4 = &temp4( 0, 0 );
17113 }
17114 {
17115 if ( _n_dims( args(3) ) > 1 )
17116 {
17117 error( "argument must be a scalar or vector" ); SWIG_fail;
17118 }
17119 if ( !( _dim( args(3), 0 ) == Alen || _dim( args(3), 0 ) == Alen - 1 ) )
17120 {
17121 error( "argument vector must be same length or one less" ); SWIG_fail;
17122 }
17123 temp5 = args(3).matrix_value();
17124 arg5 = new PLINT[Alen];
17125 _cvt_double_to( arg5, &temp5( 0, 0 ), Alen );
17126 }
17127 ecode6 = SWIG_AsVal_int(args(4), &val6);
17128 if (!SWIG_IsOK(ecode6)) {
17129 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plpoly3" "', argument " "6"" of type '" "PLBOOL""'");
17130 }
17131 arg6 = (PLBOOL)(val6);
17132 plpoly3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(int const *)arg5,arg6);
17133 _outv = octave_value();
17134 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17135 {
17136
17137 }
17138 {
17139
17140 }
17141 {
17142
17143 }
17144 {
17145 delete [] arg5;
17146 }
17147 fail:
17148 return _out;
17149 }
17150
17151
17152 SWIG_DEFUN( plprec, _wrap_plprec, _wrap_plprec_texinfo ) {
17153 PLINT arg1 ;
17154 PLINT arg2 ;
17155 int val1 ;
17156 int ecode1 = 0 ;
17157 int val2 ;
17158 int ecode2 = 0 ;
17159 octave_value_list _out;
17160 octave_value_list *_outp=&_out;
17161 octave_value _outv;
17162
17163 if (!SWIG_check_num_args("plprec",args.length(),2,2,0)) {
17164 SWIG_fail;
17165 }
17166 ecode1 = SWIG_AsVal_int(args(0), &val1);
17167 if (!SWIG_IsOK(ecode1)) {
17168 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plprec" "', argument " "1"" of type '" "PLINT""'");
17169 }
17170 arg1 = (PLINT)(val1);
17171 ecode2 = SWIG_AsVal_int(args(1), &val2);
17172 if (!SWIG_IsOK(ecode2)) {
17173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plprec" "', argument " "2"" of type '" "PLINT""'");
17174 }
17175 arg2 = (PLINT)(val2);
17176 plprec(arg1,arg2);
17177 _outv = octave_value();
17178 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17179 fail:
17180 return _out;
17181 }
17182
17183
17184 SWIG_DEFUN( plpsty, _wrap_plpsty, _wrap_plpsty_texinfo ) {
17185 PLINT arg1 ;
17186 int val1 ;
17187 int ecode1 = 0 ;
17188 octave_value_list _out;
17189 octave_value_list *_outp=&_out;
17190 octave_value _outv;
17191
17192 if (!SWIG_check_num_args("plpsty",args.length(),1,1,0)) {
17193 SWIG_fail;
17194 }
17195 ecode1 = SWIG_AsVal_int(args(0), &val1);
17196 if (!SWIG_IsOK(ecode1)) {
17197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plpsty" "', argument " "1"" of type '" "PLINT""'");
17198 }
17199 arg1 = (PLINT)(val1);
17200 plpsty(arg1);
17201 _outv = octave_value();
17202 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17203 fail:
17204 return _out;
17205 }
17206
17207
17208 SWIG_DEFUN( plptex, _wrap_plptex, _wrap_plptex_texinfo ) {
17209 PLFLT arg1 ;
17210 PLFLT arg2 ;
17211 PLFLT arg3 ;
17212 PLFLT arg4 ;
17213 PLFLT arg5 ;
17214 char *arg6 = (char *) 0 ;
17215 double val1 ;
17216 int ecode1 = 0 ;
17217 double val2 ;
17218 int ecode2 = 0 ;
17219 double val3 ;
17220 int ecode3 = 0 ;
17221 double val4 ;
17222 int ecode4 = 0 ;
17223 double val5 ;
17224 int ecode5 = 0 ;
17225 int res6 ;
17226 char *buf6 = 0 ;
17227 int alloc6 = 0 ;
17228 octave_value_list _out;
17229 octave_value_list *_outp=&_out;
17230 octave_value _outv;
17231
17232 if (!SWIG_check_num_args("plptex",args.length(),6,6,0)) {
17233 SWIG_fail;
17234 }
17235 ecode1 = SWIG_AsVal_double(args(0), &val1);
17236 if (!SWIG_IsOK(ecode1)) {
17237 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex" "', argument " "1"" of type '" "PLFLT""'");
17238 }
17239 arg1 = (PLFLT)(val1);
17240 ecode2 = SWIG_AsVal_double(args(1), &val2);
17241 if (!SWIG_IsOK(ecode2)) {
17242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex" "', argument " "2"" of type '" "PLFLT""'");
17243 }
17244 arg2 = (PLFLT)(val2);
17245 ecode3 = SWIG_AsVal_double(args(2), &val3);
17246 if (!SWIG_IsOK(ecode3)) {
17247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex" "', argument " "3"" of type '" "PLFLT""'");
17248 }
17249 arg3 = (PLFLT)(val3);
17250 ecode4 = SWIG_AsVal_double(args(3), &val4);
17251 if (!SWIG_IsOK(ecode4)) {
17252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex" "', argument " "4"" of type '" "PLFLT""'");
17253 }
17254 arg4 = (PLFLT)(val4);
17255 ecode5 = SWIG_AsVal_double(args(4), &val5);
17256 if (!SWIG_IsOK(ecode5)) {
17257 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex" "', argument " "5"" of type '" "PLFLT""'");
17258 }
17259 arg5 = (PLFLT)(val5);
17260 res6 = SWIG_AsCharPtrAndSize(args(5), &buf6, NULL, &alloc6);
17261 if (!SWIG_IsOK(res6)) {
17262 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plptex" "', argument " "6"" of type '" "char const *""'");
17263 }
17264 arg6 = (char *)(buf6);
17265 plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);
17266 _outv = octave_value();
17267 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17268 if (alloc6 == SWIG_NEWOBJ) delete[] buf6;
17269 fail:
17270 return _out;
17271 }
17272
17273
17274 SWIG_DEFUN( plptex3, _wrap_plptex3, _wrap_plptex3_texinfo ) {
17275 PLFLT arg1 ;
17276 PLFLT arg2 ;
17277 PLFLT arg3 ;
17278 PLFLT arg4 ;
17279 PLFLT arg5 ;
17280 PLFLT arg6 ;
17281 PLFLT arg7 ;
17282 PLFLT arg8 ;
17283 PLFLT arg9 ;
17284 PLFLT arg10 ;
17285 char *arg11 = (char *) 0 ;
17286 double val1 ;
17287 int ecode1 = 0 ;
17288 double val2 ;
17289 int ecode2 = 0 ;
17290 double val3 ;
17291 int ecode3 = 0 ;
17292 double val4 ;
17293 int ecode4 = 0 ;
17294 double val5 ;
17295 int ecode5 = 0 ;
17296 double val6 ;
17297 int ecode6 = 0 ;
17298 double val7 ;
17299 int ecode7 = 0 ;
17300 double val8 ;
17301 int ecode8 = 0 ;
17302 double val9 ;
17303 int ecode9 = 0 ;
17304 double val10 ;
17305 int ecode10 = 0 ;
17306 int res11 ;
17307 char *buf11 = 0 ;
17308 int alloc11 = 0 ;
17309 octave_value_list _out;
17310 octave_value_list *_outp=&_out;
17311 octave_value _outv;
17312
17313 if (!SWIG_check_num_args("plptex3",args.length(),11,11,0)) {
17314 SWIG_fail;
17315 }
17316 ecode1 = SWIG_AsVal_double(args(0), &val1);
17317 if (!SWIG_IsOK(ecode1)) {
17318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plptex3" "', argument " "1"" of type '" "PLFLT""'");
17319 }
17320 arg1 = (PLFLT)(val1);
17321 ecode2 = SWIG_AsVal_double(args(1), &val2);
17322 if (!SWIG_IsOK(ecode2)) {
17323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plptex3" "', argument " "2"" of type '" "PLFLT""'");
17324 }
17325 arg2 = (PLFLT)(val2);
17326 ecode3 = SWIG_AsVal_double(args(2), &val3);
17327 if (!SWIG_IsOK(ecode3)) {
17328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plptex3" "', argument " "3"" of type '" "PLFLT""'");
17329 }
17330 arg3 = (PLFLT)(val3);
17331 ecode4 = SWIG_AsVal_double(args(3), &val4);
17332 if (!SWIG_IsOK(ecode4)) {
17333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plptex3" "', argument " "4"" of type '" "PLFLT""'");
17334 }
17335 arg4 = (PLFLT)(val4);
17336 ecode5 = SWIG_AsVal_double(args(4), &val5);
17337 if (!SWIG_IsOK(ecode5)) {
17338 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plptex3" "', argument " "5"" of type '" "PLFLT""'");
17339 }
17340 arg5 = (PLFLT)(val5);
17341 ecode6 = SWIG_AsVal_double(args(5), &val6);
17342 if (!SWIG_IsOK(ecode6)) {
17343 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plptex3" "', argument " "6"" of type '" "PLFLT""'");
17344 }
17345 arg6 = (PLFLT)(val6);
17346 ecode7 = SWIG_AsVal_double(args(6), &val7);
17347 if (!SWIG_IsOK(ecode7)) {
17348 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plptex3" "', argument " "7"" of type '" "PLFLT""'");
17349 }
17350 arg7 = (PLFLT)(val7);
17351 ecode8 = SWIG_AsVal_double(args(7), &val8);
17352 if (!SWIG_IsOK(ecode8)) {
17353 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plptex3" "', argument " "8"" of type '" "PLFLT""'");
17354 }
17355 arg8 = (PLFLT)(val8);
17356 ecode9 = SWIG_AsVal_double(args(8), &val9);
17357 if (!SWIG_IsOK(ecode9)) {
17358 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plptex3" "', argument " "9"" of type '" "PLFLT""'");
17359 }
17360 arg9 = (PLFLT)(val9);
17361 ecode10 = SWIG_AsVal_double(args(9), &val10);
17362 if (!SWIG_IsOK(ecode10)) {
17363 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plptex3" "', argument " "10"" of type '" "PLFLT""'");
17364 }
17365 arg10 = (PLFLT)(val10);
17366 res11 = SWIG_AsCharPtrAndSize(args(10), &buf11, NULL, &alloc11);
17367 if (!SWIG_IsOK(res11)) {
17368 SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "plptex3" "', argument " "11"" of type '" "char const *""'");
17369 }
17370 arg11 = (char *)(buf11);
17371 plptex3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(char const *)arg11);
17372 _outv = octave_value();
17373 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17374 if (alloc11 == SWIG_NEWOBJ) delete[] buf11;
17375 fail:
17376 return _out;
17377 }
17378
17379
17380 SWIG_DEFUN( plrandd, _wrap_plrandd, _wrap_plrandd_texinfo ) {
17381 octave_value_list _out;
17382 octave_value_list *_outp=&_out;
17383 octave_value _outv;
17384 PLFLT result;
17385
17386 if (!SWIG_check_num_args("plrandd",args.length(),0,0,0)) {
17387 SWIG_fail;
17388 }
17389 result = (PLFLT)plrandd();
17390 _outv = SWIG_From_double((double)(result));
17391 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17392 fail:
17393 return _out;
17394 }
17395
17396
17397 SWIG_DEFUN( plreplot, _wrap_plreplot, _wrap_plreplot_texinfo ) {
17398 octave_value_list _out;
17399 octave_value_list *_outp=&_out;
17400 octave_value _outv;
17401
17402 if (!SWIG_check_num_args("plreplot",args.length(),0,0,0)) {
17403 SWIG_fail;
17404 }
17405 plreplot();
17406 _outv = octave_value();
17407 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17408 fail:
17409 return _out;
17410 }
17411
17412
17413 SWIG_DEFUN( plrgbhls, _wrap_plrgbhls, _wrap_plrgbhls_texinfo ) {
17414 PLFLT arg1 ;
17415 PLFLT arg2 ;
17416 PLFLT arg3 ;
17417 PLFLT *arg4 = (PLFLT *) 0 ;
17418 PLFLT *arg5 = (PLFLT *) 0 ;
17419 PLFLT *arg6 = (PLFLT *) 0 ;
17420 double val1 ;
17421 int ecode1 = 0 ;
17422 double val2 ;
17423 int ecode2 = 0 ;
17424 double val3 ;
17425 int ecode3 = 0 ;
17426 PLFLT temp4 ;
17427 int res4 = SWIG_TMPOBJ ;
17428 PLFLT temp5 ;
17429 int res5 = SWIG_TMPOBJ ;
17430 PLFLT temp6 ;
17431 int res6 = SWIG_TMPOBJ ;
17432 octave_value_list _out;
17433 octave_value_list *_outp=&_out;
17434 octave_value _outv;
17435
17436 arg4 = &temp4;
17437 arg5 = &temp5;
17438 arg6 = &temp6;
17439 if (!SWIG_check_num_args("plrgbhls",args.length(),3,3,0)) {
17440 SWIG_fail;
17441 }
17442 ecode1 = SWIG_AsVal_double(args(0), &val1);
17443 if (!SWIG_IsOK(ecode1)) {
17444 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plrgbhls" "', argument " "1"" of type '" "PLFLT""'");
17445 }
17446 arg1 = (PLFLT)(val1);
17447 ecode2 = SWIG_AsVal_double(args(1), &val2);
17448 if (!SWIG_IsOK(ecode2)) {
17449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plrgbhls" "', argument " "2"" of type '" "PLFLT""'");
17450 }
17451 arg2 = (PLFLT)(val2);
17452 ecode3 = SWIG_AsVal_double(args(2), &val3);
17453 if (!SWIG_IsOK(ecode3)) {
17454 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plrgbhls" "', argument " "3"" of type '" "PLFLT""'");
17455 }
17456 arg3 = (PLFLT)(val3);
17457 plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);
17458 _outv = octave_value();
17459 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17460 if (SWIG_IsTmpObj(res4)) {
17461 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg4)));
17462 } else {
17463 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17464 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_double, new_flags));
17465 }
17466 if (SWIG_IsTmpObj(res5)) {
17467 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg5)));
17468 } else {
17469 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17470 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags));
17471 }
17472 if (SWIG_IsTmpObj(res6)) {
17473 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg6)));
17474 } else {
17475 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17476 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
17477 }
17478 fail:
17479 return _out;
17480 }
17481
17482
17483 SWIG_DEFUN( plschr, _wrap_plschr, _wrap_plschr_texinfo ) {
17484 PLFLT arg1 ;
17485 PLFLT arg2 ;
17486 double val1 ;
17487 int ecode1 = 0 ;
17488 double val2 ;
17489 int ecode2 = 0 ;
17490 octave_value_list _out;
17491 octave_value_list *_outp=&_out;
17492 octave_value _outv;
17493
17494 if (!SWIG_check_num_args("plschr",args.length(),2,2,0)) {
17495 SWIG_fail;
17496 }
17497 ecode1 = SWIG_AsVal_double(args(0), &val1);
17498 if (!SWIG_IsOK(ecode1)) {
17499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plschr" "', argument " "1"" of type '" "PLFLT""'");
17500 }
17501 arg1 = (PLFLT)(val1);
17502 ecode2 = SWIG_AsVal_double(args(1), &val2);
17503 if (!SWIG_IsOK(ecode2)) {
17504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plschr" "', argument " "2"" of type '" "PLFLT""'");
17505 }
17506 arg2 = (PLFLT)(val2);
17507 plschr(arg1,arg2);
17508 _outv = octave_value();
17509 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17510 fail:
17511 return _out;
17512 }
17513
17514
17515 SWIG_DEFUN( plscmap0, _wrap_plscmap0, _wrap_plscmap0_texinfo ) {
17516 PLINT *arg1 = (PLINT *) 0 ;
17517 PLINT *arg2 = (PLINT *) 0 ;
17518 PLINT *arg3 = (PLINT *) 0 ;
17519 PLINT arg4 ;
17520 Matrix temp1 ;
17521 Matrix temp2 ;
17522 Matrix temp3 ;
17523 octave_value_list _out;
17524 octave_value_list *_outp=&_out;
17525 octave_value _outv;
17526
17527 if (!SWIG_check_num_args("plscmap0",args.length(),3,3,0)) {
17528 SWIG_fail;
17529 }
17530 {
17531 if ( _n_dims( args(0) ) > 1 )
17532 {
17533 error( "argument must be a scalar or vector" ); SWIG_fail;
17534 }
17535 Alen = (PLINT) ( _dim( args(0), 0 ) );
17536 temp1 = args(0).matrix_value();
17537 arg1 = new PLINT[Alen];
17538 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
17539 }
17540 {
17541 if ( _n_dims( args(1) ) > 1 )
17542 {
17543 error( "argument must be a scalar or vector" ); SWIG_fail;
17544 }
17545 if ( _dim( args(1), 0 ) != Alen )
17546 {
17547 error( "argument vectors must be same length" ); SWIG_fail;
17548 }
17549 temp2 = args(1).matrix_value();
17550 arg2 = new PLINT[Alen];
17551 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
17552 }
17553 {
17554 if ( _n_dims( args(2) ) > 1 )
17555 {
17556 error( "argument must be a scalar or vector" ); SWIG_fail;
17557 }
17558 if ( _dim( args(2), 0 ) != Alen )
17559 {
17560 error( "argument vectors must be same length" ); SWIG_fail;
17561 }
17562 temp3 = args(2).matrix_value();
17563 arg3 = new PLINT[Alen];
17564 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
17565 arg4 = Alen;
17566 }
17567 plscmap0((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
17568 _outv = octave_value();
17569 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17570 {
17571 delete [] arg1;
17572 }
17573 {
17574 delete [] arg2;
17575 }
17576 {
17577 delete [] arg3;
17578 }
17579 fail:
17580 return _out;
17581 }
17582
17583
17584 SWIG_DEFUN( plscmap0a, _wrap_plscmap0a, _wrap_plscmap0a_texinfo ) {
17585 PLINT *arg1 = (PLINT *) 0 ;
17586 PLINT *arg2 = (PLINT *) 0 ;
17587 PLINT *arg3 = (PLINT *) 0 ;
17588 PLFLT *arg4 = (PLFLT *) 0 ;
17589 PLINT arg5 ;
17590 Matrix temp1 ;
17591 Matrix temp2 ;
17592 Matrix temp3 ;
17593 Matrix temp4 ;
17594 octave_value_list _out;
17595 octave_value_list *_outp=&_out;
17596 octave_value _outv;
17597
17598 if (!SWIG_check_num_args("plscmap0a",args.length(),4,4,0)) {
17599 SWIG_fail;
17600 }
17601 {
17602 if ( _n_dims( args(0) ) > 1 )
17603 {
17604 error( "argument must be a scalar or vector" ); SWIG_fail;
17605 }
17606 Alen = (PLINT) ( _dim( args(0), 0 ) );
17607 temp1 = args(0).matrix_value();
17608 arg1 = new PLINT[Alen];
17609 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
17610 }
17611 {
17612 if ( _n_dims( args(1) ) > 1 )
17613 {
17614 error( "argument must be a scalar or vector" ); SWIG_fail;
17615 }
17616 if ( _dim( args(1), 0 ) != Alen )
17617 {
17618 error( "argument vectors must be same length" ); SWIG_fail;
17619 }
17620 temp2 = args(1).matrix_value();
17621 arg2 = new PLINT[Alen];
17622 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
17623 }
17624 {
17625 if ( _n_dims( args(2) ) > 1 )
17626 {
17627 error( "argument must be a scalar or vector" ); SWIG_fail;
17628 }
17629 if ( _dim( args(2), 0 ) != Alen )
17630 {
17631 error( "argument vectors must be same length" ); SWIG_fail;
17632 }
17633 temp3 = args(2).matrix_value();
17634 arg3 = new PLINT[Alen];
17635 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
17636 }
17637 {
17638 if ( _n_dims( args(3) ) > 1 )
17639 {
17640 error( "argument must be a scalar or vector" ); SWIG_fail;
17641 }
17642 if ( _dim( args(3), 0 ) != Alen )
17643 {
17644 error( "argument vectors must be same length" ); SWIG_fail;
17645 }
17646 temp4 = args(3).matrix_value();
17647 arg4 = &temp4( 0, 0 );
17648 arg5 = (PLINT) ( _dim( args(3), 0 ) );
17649 }
17650 plscmap0a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
17651 _outv = octave_value();
17652 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17653 {
17654 delete [] arg1;
17655 }
17656 {
17657 delete [] arg2;
17658 }
17659 {
17660 delete [] arg3;
17661 }
17662 {
17663
17664 }
17665 fail:
17666 return _out;
17667 }
17668
17669
17670 SWIG_DEFUN( plscmap0n, _wrap_plscmap0n, _wrap_plscmap0n_texinfo ) {
17671 PLINT arg1 ;
17672 int val1 ;
17673 int ecode1 = 0 ;
17674 octave_value_list _out;
17675 octave_value_list *_outp=&_out;
17676 octave_value _outv;
17677
17678 if (!SWIG_check_num_args("plscmap0n",args.length(),1,1,0)) {
17679 SWIG_fail;
17680 }
17681 ecode1 = SWIG_AsVal_int(args(0), &val1);
17682 if (!SWIG_IsOK(ecode1)) {
17683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap0n" "', argument " "1"" of type '" "PLINT""'");
17684 }
17685 arg1 = (PLINT)(val1);
17686 plscmap0n(arg1);
17687 _outv = octave_value();
17688 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17689 fail:
17690 return _out;
17691 }
17692
17693
17694 SWIG_DEFUN( plscmap1, _wrap_plscmap1, _wrap_plscmap1_texinfo ) {
17695 PLINT *arg1 = (PLINT *) 0 ;
17696 PLINT *arg2 = (PLINT *) 0 ;
17697 PLINT *arg3 = (PLINT *) 0 ;
17698 PLINT arg4 ;
17699 Matrix temp1 ;
17700 Matrix temp2 ;
17701 Matrix temp3 ;
17702 octave_value_list _out;
17703 octave_value_list *_outp=&_out;
17704 octave_value _outv;
17705
17706 if (!SWIG_check_num_args("plscmap1",args.length(),3,3,0)) {
17707 SWIG_fail;
17708 }
17709 {
17710 if ( _n_dims( args(0) ) > 1 )
17711 {
17712 error( "argument must be a scalar or vector" ); SWIG_fail;
17713 }
17714 Alen = (PLINT) ( _dim( args(0), 0 ) );
17715 temp1 = args(0).matrix_value();
17716 arg1 = new PLINT[Alen];
17717 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
17718 }
17719 {
17720 if ( _n_dims( args(1) ) > 1 )
17721 {
17722 error( "argument must be a scalar or vector" ); SWIG_fail;
17723 }
17724 if ( _dim( args(1), 0 ) != Alen )
17725 {
17726 error( "argument vectors must be same length" ); SWIG_fail;
17727 }
17728 temp2 = args(1).matrix_value();
17729 arg2 = new PLINT[Alen];
17730 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
17731 }
17732 {
17733 if ( _n_dims( args(2) ) > 1 )
17734 {
17735 error( "argument must be a scalar or vector" ); SWIG_fail;
17736 }
17737 if ( _dim( args(2), 0 ) != Alen )
17738 {
17739 error( "argument vectors must be same length" ); SWIG_fail;
17740 }
17741 temp3 = args(2).matrix_value();
17742 arg3 = new PLINT[Alen];
17743 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
17744 arg4 = Alen;
17745 }
17746 plscmap1((int const *)arg1,(int const *)arg2,(int const *)arg3,arg4);
17747 _outv = octave_value();
17748 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17749 {
17750 delete [] arg1;
17751 }
17752 {
17753 delete [] arg2;
17754 }
17755 {
17756 delete [] arg3;
17757 }
17758 fail:
17759 return _out;
17760 }
17761
17762
17763 SWIG_DEFUN( plscmap1a, _wrap_plscmap1a, _wrap_plscmap1a_texinfo ) {
17764 PLINT *arg1 = (PLINT *) 0 ;
17765 PLINT *arg2 = (PLINT *) 0 ;
17766 PLINT *arg3 = (PLINT *) 0 ;
17767 PLFLT *arg4 = (PLFLT *) 0 ;
17768 PLINT arg5 ;
17769 Matrix temp1 ;
17770 Matrix temp2 ;
17771 Matrix temp3 ;
17772 Matrix temp4 ;
17773 octave_value_list _out;
17774 octave_value_list *_outp=&_out;
17775 octave_value _outv;
17776
17777 if (!SWIG_check_num_args("plscmap1a",args.length(),4,4,0)) {
17778 SWIG_fail;
17779 }
17780 {
17781 if ( _n_dims( args(0) ) > 1 )
17782 {
17783 error( "argument must be a scalar or vector" ); SWIG_fail;
17784 }
17785 Alen = (PLINT) ( _dim( args(0), 0 ) );
17786 temp1 = args(0).matrix_value();
17787 arg1 = new PLINT[Alen];
17788 _cvt_double_to( arg1, &temp1( 0, 0 ), Alen );
17789 }
17790 {
17791 if ( _n_dims( args(1) ) > 1 )
17792 {
17793 error( "argument must be a scalar or vector" ); SWIG_fail;
17794 }
17795 if ( _dim( args(1), 0 ) != Alen )
17796 {
17797 error( "argument vectors must be same length" ); SWIG_fail;
17798 }
17799 temp2 = args(1).matrix_value();
17800 arg2 = new PLINT[Alen];
17801 _cvt_double_to( arg2, &temp2( 0, 0 ), Alen );
17802 }
17803 {
17804 if ( _n_dims( args(2) ) > 1 )
17805 {
17806 error( "argument must be a scalar or vector" ); SWIG_fail;
17807 }
17808 if ( _dim( args(2), 0 ) != Alen )
17809 {
17810 error( "argument vectors must be same length" ); SWIG_fail;
17811 }
17812 temp3 = args(2).matrix_value();
17813 arg3 = new PLINT[Alen];
17814 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
17815 }
17816 {
17817 if ( _n_dims( args(3) ) > 1 )
17818 {
17819 error( "argument must be a scalar or vector" ); SWIG_fail;
17820 }
17821 if ( _dim( args(3), 0 ) != Alen )
17822 {
17823 error( "argument vectors must be same length" ); SWIG_fail;
17824 }
17825 temp4 = args(3).matrix_value();
17826 arg4 = &temp4( 0, 0 );
17827 arg5 = (PLINT) ( _dim( args(3), 0 ) );
17828 }
17829 plscmap1a((int const *)arg1,(int const *)arg2,(int const *)arg3,(double const *)arg4,arg5);
17830 _outv = octave_value();
17831 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17832 {
17833 delete [] arg1;
17834 }
17835 {
17836 delete [] arg2;
17837 }
17838 {
17839 delete [] arg3;
17840 }
17841 {
17842
17843 }
17844 fail:
17845 return _out;
17846 }
17847
17848
17849 SWIG_DEFUN( plscmap1l, _wrap_plscmap1l, _wrap_plscmap1l_texinfo ) {
17850 PLBOOL arg1 ;
17851 PLINT arg2 ;
17852 PLFLT *arg3 = (PLFLT *) 0 ;
17853 PLFLT *arg4 = (PLFLT *) 0 ;
17854 PLFLT *arg5 = (PLFLT *) 0 ;
17855 PLFLT *arg6 = (PLFLT *) 0 ;
17856 PLBOOL *arg7 = (PLBOOL *) 0 ;
17857 int val1 ;
17858 int ecode1 = 0 ;
17859 Matrix temp2 ;
17860 Matrix temp4 ;
17861 Matrix temp5 ;
17862 Matrix temp6 ;
17863 Matrix temp7 ;
17864 octave_value_list _out;
17865 octave_value_list *_outp=&_out;
17866 octave_value _outv;
17867
17868 if (!SWIG_check_num_args("plscmap1l",args.length(),6,6,0)) {
17869 SWIG_fail;
17870 }
17871 ecode1 = SWIG_AsVal_int(args(0), &val1);
17872 if (!SWIG_IsOK(ecode1)) {
17873 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1l" "', argument " "1"" of type '" "PLBOOL""'");
17874 }
17875 arg1 = (PLBOOL)(val1);
17876 {
17877 if ( _n_dims( args(1) ) > 1 )
17878 {
17879 error( "argument must be a scalar or vector" ); SWIG_fail;
17880 }
17881 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
17882 temp2 = args(1).matrix_value();
17883 arg3 = &temp2( 0, 0 );
17884 }
17885 {
17886 if ( _n_dims( args(2) ) > 1 )
17887 {
17888 error( "argument must be a scalar or vector" ); SWIG_fail;
17889 }
17890 if ( _dim( args(2), 0 ) != Alen )
17891 {
17892 error( "argument vectors must be same length" ); SWIG_fail;
17893 }
17894 temp4 = args(2).matrix_value();
17895 arg4 = &temp4( 0, 0 );
17896 }
17897 {
17898 if ( _n_dims( args(3) ) > 1 )
17899 {
17900 error( "argument must be a scalar or vector" ); SWIG_fail;
17901 }
17902 if ( _dim( args(3), 0 ) != Alen )
17903 {
17904 error( "argument vectors must be same length" ); SWIG_fail;
17905 }
17906 temp5 = args(3).matrix_value();
17907 arg5 = &temp5( 0, 0 );
17908 }
17909 {
17910 if ( _n_dims( args(4) ) > 1 )
17911 {
17912 error( "argument must be a scalar or vector" ); SWIG_fail;
17913 }
17914 if ( _dim( args(4), 0 ) != Alen )
17915 {
17916 error( "argument vectors must be same length" ); SWIG_fail;
17917 }
17918 temp6 = args(4).matrix_value();
17919 arg6 = &temp6( 0, 0 );
17920 }
17921 {
17922 if ( _n_dims( args(5) ) > 1 )
17923 {
17924 error( "argument must be a scalar or vector" ); SWIG_fail;
17925 }
17926 if ( !( _dim( args(5), 0 ) == Alen || _dim( args(5), 0 ) == Alen - 1 ) )
17927 {
17928 error( "argument vector must be same length or one less" ); SWIG_fail;
17929 }
17930 temp7 = args(5).matrix_value();
17931 arg7 = new PLINT[Alen];
17932 _cvt_double_to( arg7, &temp7( 0, 0 ), Alen );
17933 }
17934 plscmap1l(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(int const *)arg7);
17935 _outv = octave_value();
17936 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
17937 {
17938
17939 }
17940 {
17941
17942 }
17943 {
17944
17945 }
17946 {
17947
17948 }
17949 {
17950 delete [] arg7;
17951 }
17952 fail:
17953 return _out;
17954 }
17955
17956
17957 SWIG_DEFUN( plscmap1la, _wrap_plscmap1la, _wrap_plscmap1la_texinfo ) {
17958 PLBOOL arg1 ;
17959 PLINT arg2 ;
17960 PLFLT *arg3 = (PLFLT *) 0 ;
17961 PLFLT *arg4 = (PLFLT *) 0 ;
17962 PLFLT *arg5 = (PLFLT *) 0 ;
17963 PLFLT *arg6 = (PLFLT *) 0 ;
17964 PLFLT *arg7 = (PLFLT *) 0 ;
17965 PLBOOL *arg8 = (PLBOOL *) 0 ;
17966 int val1 ;
17967 int ecode1 = 0 ;
17968 Matrix temp2 ;
17969 Matrix temp4 ;
17970 Matrix temp5 ;
17971 Matrix temp6 ;
17972 Matrix temp7 ;
17973 Matrix temp8 ;
17974 octave_value_list _out;
17975 octave_value_list *_outp=&_out;
17976 octave_value _outv;
17977
17978 if (!SWIG_check_num_args("plscmap1la",args.length(),7,7,0)) {
17979 SWIG_fail;
17980 }
17981 ecode1 = SWIG_AsVal_int(args(0), &val1);
17982 if (!SWIG_IsOK(ecode1)) {
17983 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1la" "', argument " "1"" of type '" "PLBOOL""'");
17984 }
17985 arg1 = (PLBOOL)(val1);
17986 {
17987 if ( _n_dims( args(1) ) > 1 )
17988 {
17989 error( "argument must be a scalar or vector" ); SWIG_fail;
17990 }
17991 arg2 = Alen = (PLINT) ( _dim( args(1), 0 ) );
17992 temp2 = args(1).matrix_value();
17993 arg3 = &temp2( 0, 0 );
17994 }
17995 {
17996 if ( _n_dims( args(2) ) > 1 )
17997 {
17998 error( "argument must be a scalar or vector" ); SWIG_fail;
17999 }
18000 if ( _dim( args(2), 0 ) != Alen )
18001 {
18002 error( "argument vectors must be same length" ); SWIG_fail;
18003 }
18004 temp4 = args(2).matrix_value();
18005 arg4 = &temp4( 0, 0 );
18006 }
18007 {
18008 if ( _n_dims( args(3) ) > 1 )
18009 {
18010 error( "argument must be a scalar or vector" ); SWIG_fail;
18011 }
18012 if ( _dim( args(3), 0 ) != Alen )
18013 {
18014 error( "argument vectors must be same length" ); SWIG_fail;
18015 }
18016 temp5 = args(3).matrix_value();
18017 arg5 = &temp5( 0, 0 );
18018 }
18019 {
18020 if ( _n_dims( args(4) ) > 1 )
18021 {
18022 error( "argument must be a scalar or vector" ); SWIG_fail;
18023 }
18024 if ( _dim( args(4), 0 ) != Alen )
18025 {
18026 error( "argument vectors must be same length" ); SWIG_fail;
18027 }
18028 temp6 = args(4).matrix_value();
18029 arg6 = &temp6( 0, 0 );
18030 }
18031 {
18032 if ( _n_dims( args(5) ) > 1 )
18033 {
18034 error( "argument must be a scalar or vector" ); SWIG_fail;
18035 }
18036 if ( _dim( args(5), 0 ) != Alen )
18037 {
18038 error( "argument vectors must be same length" ); SWIG_fail;
18039 }
18040 temp7 = args(5).matrix_value();
18041 arg7 = &temp7( 0, 0 );
18042 }
18043 {
18044 if ( _n_dims( args(6) ) > 1 )
18045 {
18046 error( "argument must be a scalar or vector" ); SWIG_fail;
18047 }
18048 if ( !( _dim( args(6), 0 ) == Alen || _dim( args(6), 0 ) == Alen - 1 ) )
18049 {
18050 error( "argument vector must be same length or one less" ); SWIG_fail;
18051 }
18052 temp8 = args(6).matrix_value();
18053 arg8 = new PLINT[Alen];
18054 _cvt_double_to( arg8, &temp8( 0, 0 ), Alen );
18055 }
18056 plscmap1la(arg1,arg2,(double const *)arg3,(double const *)arg4,(double const *)arg5,(double const *)arg6,(double const *)arg7,(int const *)arg8);
18057 _outv = octave_value();
18058 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18059 {
18060
18061 }
18062 {
18063
18064 }
18065 {
18066
18067 }
18068 {
18069
18070 }
18071 {
18072
18073 }
18074 {
18075 delete [] arg8;
18076 }
18077 fail:
18078 return _out;
18079 }
18080
18081
18082 SWIG_DEFUN( plscmap1n, _wrap_plscmap1n, _wrap_plscmap1n_texinfo ) {
18083 PLINT arg1 ;
18084 int val1 ;
18085 int ecode1 = 0 ;
18086 octave_value_list _out;
18087 octave_value_list *_outp=&_out;
18088 octave_value _outv;
18089
18090 if (!SWIG_check_num_args("plscmap1n",args.length(),1,1,0)) {
18091 SWIG_fail;
18092 }
18093 ecode1 = SWIG_AsVal_int(args(0), &val1);
18094 if (!SWIG_IsOK(ecode1)) {
18095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1n" "', argument " "1"" of type '" "PLINT""'");
18096 }
18097 arg1 = (PLINT)(val1);
18098 plscmap1n(arg1);
18099 _outv = octave_value();
18100 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18101 fail:
18102 return _out;
18103 }
18104
18105
18106 SWIG_DEFUN( plscmap1_range, _wrap_plscmap1_range, std::string() ) {
18107 PLFLT arg1 ;
18108 PLFLT arg2 ;
18109 double val1 ;
18110 int ecode1 = 0 ;
18111 double val2 ;
18112 int ecode2 = 0 ;
18113 octave_value_list _out;
18114 octave_value_list *_outp=&_out;
18115 octave_value _outv;
18116
18117 if (!SWIG_check_num_args("plscmap1_range",args.length(),2,2,0)) {
18118 SWIG_fail;
18119 }
18120 ecode1 = SWIG_AsVal_double(args(0), &val1);
18121 if (!SWIG_IsOK(ecode1)) {
18122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscmap1_range" "', argument " "1"" of type '" "PLFLT""'");
18123 }
18124 arg1 = (PLFLT)(val1);
18125 ecode2 = SWIG_AsVal_double(args(1), &val2);
18126 if (!SWIG_IsOK(ecode2)) {
18127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscmap1_range" "', argument " "2"" of type '" "PLFLT""'");
18128 }
18129 arg2 = (PLFLT)(val2);
18130 plscmap1_range(arg1,arg2);
18131 _outv = octave_value();
18132 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18133 fail:
18134 return _out;
18135 }
18136
18137
18138 SWIG_DEFUN( plgcmap1_range, _wrap_plgcmap1_range, std::string() ) {
18139 PLFLT *arg1 = (PLFLT *) 0 ;
18140 PLFLT *arg2 = (PLFLT *) 0 ;
18141 PLFLT temp1 ;
18142 int res1 = SWIG_TMPOBJ ;
18143 PLFLT temp2 ;
18144 int res2 = SWIG_TMPOBJ ;
18145 octave_value_list _out;
18146 octave_value_list *_outp=&_out;
18147 octave_value _outv;
18148
18149 arg1 = &temp1;
18150 arg2 = &temp2;
18151 if (!SWIG_check_num_args("plgcmap1_range",args.length(),0,0,0)) {
18152 SWIG_fail;
18153 }
18154 plgcmap1_range(arg1,arg2);
18155 _outv = octave_value();
18156 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18157 if (SWIG_IsTmpObj(res1)) {
18158 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg1)));
18159 } else {
18160 int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18161 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_double, new_flags));
18162 }
18163 if (SWIG_IsTmpObj(res2)) {
18164 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_double((*arg2)));
18165 } else {
18166 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18167 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags));
18168 }
18169 fail:
18170 return _out;
18171 }
18172
18173
18174 SWIG_DEFUN( plscol0, _wrap_plscol0, _wrap_plscol0_texinfo ) {
18175 PLINT arg1 ;
18176 PLINT arg2 ;
18177 PLINT arg3 ;
18178 PLINT arg4 ;
18179 int val1 ;
18180 int ecode1 = 0 ;
18181 int val2 ;
18182 int ecode2 = 0 ;
18183 int val3 ;
18184 int ecode3 = 0 ;
18185 int val4 ;
18186 int ecode4 = 0 ;
18187 octave_value_list _out;
18188 octave_value_list *_outp=&_out;
18189 octave_value _outv;
18190
18191 if (!SWIG_check_num_args("plscol0",args.length(),4,4,0)) {
18192 SWIG_fail;
18193 }
18194 ecode1 = SWIG_AsVal_int(args(0), &val1);
18195 if (!SWIG_IsOK(ecode1)) {
18196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0" "', argument " "1"" of type '" "PLINT""'");
18197 }
18198 arg1 = (PLINT)(val1);
18199 ecode2 = SWIG_AsVal_int(args(1), &val2);
18200 if (!SWIG_IsOK(ecode2)) {
18201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0" "', argument " "2"" of type '" "PLINT""'");
18202 }
18203 arg2 = (PLINT)(val2);
18204 ecode3 = SWIG_AsVal_int(args(2), &val3);
18205 if (!SWIG_IsOK(ecode3)) {
18206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0" "', argument " "3"" of type '" "PLINT""'");
18207 }
18208 arg3 = (PLINT)(val3);
18209 ecode4 = SWIG_AsVal_int(args(3), &val4);
18210 if (!SWIG_IsOK(ecode4)) {
18211 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0" "', argument " "4"" of type '" "PLINT""'");
18212 }
18213 arg4 = (PLINT)(val4);
18214 plscol0(arg1,arg2,arg3,arg4);
18215 _outv = octave_value();
18216 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18217 fail:
18218 return _out;
18219 }
18220
18221
18222 SWIG_DEFUN( plscol0a, _wrap_plscol0a, _wrap_plscol0a_texinfo ) {
18223 PLINT arg1 ;
18224 PLINT arg2 ;
18225 PLINT arg3 ;
18226 PLINT arg4 ;
18227 PLFLT arg5 ;
18228 int val1 ;
18229 int ecode1 = 0 ;
18230 int val2 ;
18231 int ecode2 = 0 ;
18232 int val3 ;
18233 int ecode3 = 0 ;
18234 int val4 ;
18235 int ecode4 = 0 ;
18236 double val5 ;
18237 int ecode5 = 0 ;
18238 octave_value_list _out;
18239 octave_value_list *_outp=&_out;
18240 octave_value _outv;
18241
18242 if (!SWIG_check_num_args("plscol0a",args.length(),5,5,0)) {
18243 SWIG_fail;
18244 }
18245 ecode1 = SWIG_AsVal_int(args(0), &val1);
18246 if (!SWIG_IsOK(ecode1)) {
18247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscol0a" "', argument " "1"" of type '" "PLINT""'");
18248 }
18249 arg1 = (PLINT)(val1);
18250 ecode2 = SWIG_AsVal_int(args(1), &val2);
18251 if (!SWIG_IsOK(ecode2)) {
18252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscol0a" "', argument " "2"" of type '" "PLINT""'");
18253 }
18254 arg2 = (PLINT)(val2);
18255 ecode3 = SWIG_AsVal_int(args(2), &val3);
18256 if (!SWIG_IsOK(ecode3)) {
18257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscol0a" "', argument " "3"" of type '" "PLINT""'");
18258 }
18259 arg3 = (PLINT)(val3);
18260 ecode4 = SWIG_AsVal_int(args(3), &val4);
18261 if (!SWIG_IsOK(ecode4)) {
18262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscol0a" "', argument " "4"" of type '" "PLINT""'");
18263 }
18264 arg4 = (PLINT)(val4);
18265 ecode5 = SWIG_AsVal_double(args(4), &val5);
18266 if (!SWIG_IsOK(ecode5)) {
18267 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plscol0a" "', argument " "5"" of type '" "PLFLT""'");
18268 }
18269 arg5 = (PLFLT)(val5);
18270 plscol0a(arg1,arg2,arg3,arg4,arg5);
18271 _outv = octave_value();
18272 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18273 fail:
18274 return _out;
18275 }
18276
18277
18278 SWIG_DEFUN( plscolbg, _wrap_plscolbg, _wrap_plscolbg_texinfo ) {
18279 PLINT arg1 ;
18280 PLINT arg2 ;
18281 PLINT arg3 ;
18282 int val1 ;
18283 int ecode1 = 0 ;
18284 int val2 ;
18285 int ecode2 = 0 ;
18286 int val3 ;
18287 int ecode3 = 0 ;
18288 octave_value_list _out;
18289 octave_value_list *_outp=&_out;
18290 octave_value _outv;
18291
18292 if (!SWIG_check_num_args("plscolbg",args.length(),3,3,0)) {
18293 SWIG_fail;
18294 }
18295 ecode1 = SWIG_AsVal_int(args(0), &val1);
18296 if (!SWIG_IsOK(ecode1)) {
18297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbg" "', argument " "1"" of type '" "PLINT""'");
18298 }
18299 arg1 = (PLINT)(val1);
18300 ecode2 = SWIG_AsVal_int(args(1), &val2);
18301 if (!SWIG_IsOK(ecode2)) {
18302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbg" "', argument " "2"" of type '" "PLINT""'");
18303 }
18304 arg2 = (PLINT)(val2);
18305 ecode3 = SWIG_AsVal_int(args(2), &val3);
18306 if (!SWIG_IsOK(ecode3)) {
18307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbg" "', argument " "3"" of type '" "PLINT""'");
18308 }
18309 arg3 = (PLINT)(val3);
18310 plscolbg(arg1,arg2,arg3);
18311 _outv = octave_value();
18312 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18313 fail:
18314 return _out;
18315 }
18316
18317
18318 SWIG_DEFUN( plscolbga, _wrap_plscolbga, _wrap_plscolbga_texinfo ) {
18319 PLINT arg1 ;
18320 PLINT arg2 ;
18321 PLINT arg3 ;
18322 PLFLT arg4 ;
18323 int val1 ;
18324 int ecode1 = 0 ;
18325 int val2 ;
18326 int ecode2 = 0 ;
18327 int val3 ;
18328 int ecode3 = 0 ;
18329 double val4 ;
18330 int ecode4 = 0 ;
18331 octave_value_list _out;
18332 octave_value_list *_outp=&_out;
18333 octave_value _outv;
18334
18335 if (!SWIG_check_num_args("plscolbga",args.length(),4,4,0)) {
18336 SWIG_fail;
18337 }
18338 ecode1 = SWIG_AsVal_int(args(0), &val1);
18339 if (!SWIG_IsOK(ecode1)) {
18340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolbga" "', argument " "1"" of type '" "PLINT""'");
18341 }
18342 arg1 = (PLINT)(val1);
18343 ecode2 = SWIG_AsVal_int(args(1), &val2);
18344 if (!SWIG_IsOK(ecode2)) {
18345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plscolbga" "', argument " "2"" of type '" "PLINT""'");
18346 }
18347 arg2 = (PLINT)(val2);
18348 ecode3 = SWIG_AsVal_int(args(2), &val3);
18349 if (!SWIG_IsOK(ecode3)) {
18350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plscolbga" "', argument " "3"" of type '" "PLINT""'");
18351 }
18352 arg3 = (PLINT)(val3);
18353 ecode4 = SWIG_AsVal_double(args(3), &val4);
18354 if (!SWIG_IsOK(ecode4)) {
18355 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plscolbga" "', argument " "4"" of type '" "PLFLT""'");
18356 }
18357 arg4 = (PLFLT)(val4);
18358 plscolbga(arg1,arg2,arg3,arg4);
18359 _outv = octave_value();
18360 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18361 fail:
18362 return _out;
18363 }
18364
18365
18366 SWIG_DEFUN( plscolor, _wrap_plscolor, _wrap_plscolor_texinfo ) {
18367 PLINT arg1 ;
18368 int val1 ;
18369 int ecode1 = 0 ;
18370 octave_value_list _out;
18371 octave_value_list *_outp=&_out;
18372 octave_value _outv;
18373
18374 if (!SWIG_check_num_args("plscolor",args.length(),1,1,0)) {
18375 SWIG_fail;
18376 }
18377 ecode1 = SWIG_AsVal_int(args(0), &val1);
18378 if (!SWIG_IsOK(ecode1)) {
18379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscolor" "', argument " "1"" of type '" "PLINT""'");
18380 }
18381 arg1 = (PLINT)(val1);
18382 plscolor(arg1);
18383 _outv = octave_value();
18384 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18385 fail:
18386 return _out;
18387 }
18388
18389
18390 SWIG_DEFUN( plscompression, _wrap_plscompression, _wrap_plscompression_texinfo ) {
18391 PLINT arg1 ;
18392 int val1 ;
18393 int ecode1 = 0 ;
18394 octave_value_list _out;
18395 octave_value_list *_outp=&_out;
18396 octave_value _outv;
18397
18398 if (!SWIG_check_num_args("plscompression",args.length(),1,1,0)) {
18399 SWIG_fail;
18400 }
18401 ecode1 = SWIG_AsVal_int(args(0), &val1);
18402 if (!SWIG_IsOK(ecode1)) {
18403 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plscompression" "', argument " "1"" of type '" "PLINT""'");
18404 }
18405 arg1 = (PLINT)(val1);
18406 plscompression(arg1);
18407 _outv = octave_value();
18408 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18409 fail:
18410 return _out;
18411 }
18412
18413
18414 SWIG_DEFUN( plsdev, _wrap_plsdev, _wrap_plsdev_texinfo ) {
18415 char *arg1 = (char *) 0 ;
18416 int res1 ;
18417 char *buf1 = 0 ;
18418 int alloc1 = 0 ;
18419 octave_value_list _out;
18420 octave_value_list *_outp=&_out;
18421 octave_value _outv;
18422
18423 if (!SWIG_check_num_args("plsdev",args.length(),1,1,0)) {
18424 SWIG_fail;
18425 }
18426 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18427 if (!SWIG_IsOK(res1)) {
18428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsdev" "', argument " "1"" of type '" "char const *""'");
18429 }
18430 arg1 = (char *)(buf1);
18431 plsdev((char const *)arg1);
18432 _outv = octave_value();
18433 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18434 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18435 fail:
18436 return _out;
18437 }
18438
18439
18440 SWIG_DEFUN( plsdidev, _wrap_plsdidev, _wrap_plsdidev_texinfo ) {
18441 PLFLT arg1 ;
18442 PLFLT arg2 ;
18443 PLFLT arg3 ;
18444 PLFLT arg4 ;
18445 double val1 ;
18446 int ecode1 = 0 ;
18447 double val2 ;
18448 int ecode2 = 0 ;
18449 double val3 ;
18450 int ecode3 = 0 ;
18451 double val4 ;
18452 int ecode4 = 0 ;
18453 octave_value_list _out;
18454 octave_value_list *_outp=&_out;
18455 octave_value _outv;
18456
18457 if (!SWIG_check_num_args("plsdidev",args.length(),4,4,0)) {
18458 SWIG_fail;
18459 }
18460 ecode1 = SWIG_AsVal_double(args(0), &val1);
18461 if (!SWIG_IsOK(ecode1)) {
18462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdidev" "', argument " "1"" of type '" "PLFLT""'");
18463 }
18464 arg1 = (PLFLT)(val1);
18465 ecode2 = SWIG_AsVal_double(args(1), &val2);
18466 if (!SWIG_IsOK(ecode2)) {
18467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdidev" "', argument " "2"" of type '" "PLFLT""'");
18468 }
18469 arg2 = (PLFLT)(val2);
18470 ecode3 = SWIG_AsVal_double(args(2), &val3);
18471 if (!SWIG_IsOK(ecode3)) {
18472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdidev" "', argument " "3"" of type '" "PLFLT""'");
18473 }
18474 arg3 = (PLFLT)(val3);
18475 ecode4 = SWIG_AsVal_double(args(3), &val4);
18476 if (!SWIG_IsOK(ecode4)) {
18477 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdidev" "', argument " "4"" of type '" "PLFLT""'");
18478 }
18479 arg4 = (PLFLT)(val4);
18480 plsdidev(arg1,arg2,arg3,arg4);
18481 _outv = octave_value();
18482 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18483 fail:
18484 return _out;
18485 }
18486
18487
18488 SWIG_DEFUN( plsdimap, _wrap_plsdimap, _wrap_plsdimap_texinfo ) {
18489 PLINT arg1 ;
18490 PLINT arg2 ;
18491 PLINT arg3 ;
18492 PLINT arg4 ;
18493 PLFLT arg5 ;
18494 PLFLT arg6 ;
18495 int val1 ;
18496 int ecode1 = 0 ;
18497 int val2 ;
18498 int ecode2 = 0 ;
18499 int val3 ;
18500 int ecode3 = 0 ;
18501 int val4 ;
18502 int ecode4 = 0 ;
18503 double val5 ;
18504 int ecode5 = 0 ;
18505 double val6 ;
18506 int ecode6 = 0 ;
18507 octave_value_list _out;
18508 octave_value_list *_outp=&_out;
18509 octave_value _outv;
18510
18511 if (!SWIG_check_num_args("plsdimap",args.length(),6,6,0)) {
18512 SWIG_fail;
18513 }
18514 ecode1 = SWIG_AsVal_int(args(0), &val1);
18515 if (!SWIG_IsOK(ecode1)) {
18516 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdimap" "', argument " "1"" of type '" "PLINT""'");
18517 }
18518 arg1 = (PLINT)(val1);
18519 ecode2 = SWIG_AsVal_int(args(1), &val2);
18520 if (!SWIG_IsOK(ecode2)) {
18521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdimap" "', argument " "2"" of type '" "PLINT""'");
18522 }
18523 arg2 = (PLINT)(val2);
18524 ecode3 = SWIG_AsVal_int(args(2), &val3);
18525 if (!SWIG_IsOK(ecode3)) {
18526 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdimap" "', argument " "3"" of type '" "PLINT""'");
18527 }
18528 arg3 = (PLINT)(val3);
18529 ecode4 = SWIG_AsVal_int(args(3), &val4);
18530 if (!SWIG_IsOK(ecode4)) {
18531 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdimap" "', argument " "4"" of type '" "PLINT""'");
18532 }
18533 arg4 = (PLINT)(val4);
18534 ecode5 = SWIG_AsVal_double(args(4), &val5);
18535 if (!SWIG_IsOK(ecode5)) {
18536 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plsdimap" "', argument " "5"" of type '" "PLFLT""'");
18537 }
18538 arg5 = (PLFLT)(val5);
18539 ecode6 = SWIG_AsVal_double(args(5), &val6);
18540 if (!SWIG_IsOK(ecode6)) {
18541 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plsdimap" "', argument " "6"" of type '" "PLFLT""'");
18542 }
18543 arg6 = (PLFLT)(val6);
18544 plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);
18545 _outv = octave_value();
18546 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18547 fail:
18548 return _out;
18549 }
18550
18551
18552 SWIG_DEFUN( plsdiori, _wrap_plsdiori, _wrap_plsdiori_texinfo ) {
18553 PLFLT arg1 ;
18554 double val1 ;
18555 int ecode1 = 0 ;
18556 octave_value_list _out;
18557 octave_value_list *_outp=&_out;
18558 octave_value _outv;
18559
18560 if (!SWIG_check_num_args("plsdiori",args.length(),1,1,0)) {
18561 SWIG_fail;
18562 }
18563 ecode1 = SWIG_AsVal_double(args(0), &val1);
18564 if (!SWIG_IsOK(ecode1)) {
18565 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiori" "', argument " "1"" of type '" "PLFLT""'");
18566 }
18567 arg1 = (PLFLT)(val1);
18568 plsdiori(arg1);
18569 _outv = octave_value();
18570 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18571 fail:
18572 return _out;
18573 }
18574
18575
18576 SWIG_DEFUN( plsdiplt, _wrap_plsdiplt, _wrap_plsdiplt_texinfo ) {
18577 PLFLT arg1 ;
18578 PLFLT arg2 ;
18579 PLFLT arg3 ;
18580 PLFLT arg4 ;
18581 double val1 ;
18582 int ecode1 = 0 ;
18583 double val2 ;
18584 int ecode2 = 0 ;
18585 double val3 ;
18586 int ecode3 = 0 ;
18587 double val4 ;
18588 int ecode4 = 0 ;
18589 octave_value_list _out;
18590 octave_value_list *_outp=&_out;
18591 octave_value _outv;
18592
18593 if (!SWIG_check_num_args("plsdiplt",args.length(),4,4,0)) {
18594 SWIG_fail;
18595 }
18596 ecode1 = SWIG_AsVal_double(args(0), &val1);
18597 if (!SWIG_IsOK(ecode1)) {
18598 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplt" "', argument " "1"" of type '" "PLFLT""'");
18599 }
18600 arg1 = (PLFLT)(val1);
18601 ecode2 = SWIG_AsVal_double(args(1), &val2);
18602 if (!SWIG_IsOK(ecode2)) {
18603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplt" "', argument " "2"" of type '" "PLFLT""'");
18604 }
18605 arg2 = (PLFLT)(val2);
18606 ecode3 = SWIG_AsVal_double(args(2), &val3);
18607 if (!SWIG_IsOK(ecode3)) {
18608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplt" "', argument " "3"" of type '" "PLFLT""'");
18609 }
18610 arg3 = (PLFLT)(val3);
18611 ecode4 = SWIG_AsVal_double(args(3), &val4);
18612 if (!SWIG_IsOK(ecode4)) {
18613 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplt" "', argument " "4"" of type '" "PLFLT""'");
18614 }
18615 arg4 = (PLFLT)(val4);
18616 plsdiplt(arg1,arg2,arg3,arg4);
18617 _outv = octave_value();
18618 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18619 fail:
18620 return _out;
18621 }
18622
18623
18624 SWIG_DEFUN( plsdiplz, _wrap_plsdiplz, _wrap_plsdiplz_texinfo ) {
18625 PLFLT arg1 ;
18626 PLFLT arg2 ;
18627 PLFLT arg3 ;
18628 PLFLT arg4 ;
18629 double val1 ;
18630 int ecode1 = 0 ;
18631 double val2 ;
18632 int ecode2 = 0 ;
18633 double val3 ;
18634 int ecode3 = 0 ;
18635 double val4 ;
18636 int ecode4 = 0 ;
18637 octave_value_list _out;
18638 octave_value_list *_outp=&_out;
18639 octave_value _outv;
18640
18641 if (!SWIG_check_num_args("plsdiplz",args.length(),4,4,0)) {
18642 SWIG_fail;
18643 }
18644 ecode1 = SWIG_AsVal_double(args(0), &val1);
18645 if (!SWIG_IsOK(ecode1)) {
18646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsdiplz" "', argument " "1"" of type '" "PLFLT""'");
18647 }
18648 arg1 = (PLFLT)(val1);
18649 ecode2 = SWIG_AsVal_double(args(1), &val2);
18650 if (!SWIG_IsOK(ecode2)) {
18651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsdiplz" "', argument " "2"" of type '" "PLFLT""'");
18652 }
18653 arg2 = (PLFLT)(val2);
18654 ecode3 = SWIG_AsVal_double(args(2), &val3);
18655 if (!SWIG_IsOK(ecode3)) {
18656 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsdiplz" "', argument " "3"" of type '" "PLFLT""'");
18657 }
18658 arg3 = (PLFLT)(val3);
18659 ecode4 = SWIG_AsVal_double(args(3), &val4);
18660 if (!SWIG_IsOK(ecode4)) {
18661 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsdiplz" "', argument " "4"" of type '" "PLFLT""'");
18662 }
18663 arg4 = (PLFLT)(val4);
18664 plsdiplz(arg1,arg2,arg3,arg4);
18665 _outv = octave_value();
18666 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18667 fail:
18668 return _out;
18669 }
18670
18671
18672 SWIG_DEFUN( plseed, _wrap_plseed, _wrap_plseed_texinfo ) {
18673 unsigned int arg1 ;
18674 unsigned int val1 ;
18675 int ecode1 = 0 ;
18676 octave_value_list _out;
18677 octave_value_list *_outp=&_out;
18678 octave_value _outv;
18679
18680 if (!SWIG_check_num_args("plseed",args.length(),1,1,0)) {
18681 SWIG_fail;
18682 }
18683 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
18684 if (!SWIG_IsOK(ecode1)) {
18685 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plseed" "', argument " "1"" of type '" "unsigned int""'");
18686 }
18687 arg1 = (unsigned int)(val1);
18688 plseed(arg1);
18689 _outv = octave_value();
18690 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18691 fail:
18692 return _out;
18693 }
18694
18695
18696 SWIG_DEFUN( plsesc, _wrap_plsesc, _wrap_plsesc_texinfo ) {
18697 char arg1 ;
18698 char val1 ;
18699 int ecode1 = 0 ;
18700 octave_value_list _out;
18701 octave_value_list *_outp=&_out;
18702 octave_value _outv;
18703
18704 if (!SWIG_check_num_args("plsesc",args.length(),1,1,0)) {
18705 SWIG_fail;
18706 }
18707 ecode1 = SWIG_AsVal_char(args(0), &val1);
18708 if (!SWIG_IsOK(ecode1)) {
18709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsesc" "', argument " "1"" of type '" "char""'");
18710 }
18711 arg1 = (char)(val1);
18712 plsesc(arg1);
18713 _outv = octave_value();
18714 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18715 fail:
18716 return _out;
18717 }
18718
18719
18720 SWIG_DEFUN( plSetOpt, _wrap_plSetOpt, _wrap_plSetOpt_texinfo ) {
18721 char *arg1 = (char *) 0 ;
18722 char *arg2 = (char *) 0 ;
18723 int res1 ;
18724 char *buf1 = 0 ;
18725 int alloc1 = 0 ;
18726 int res2 ;
18727 char *buf2 = 0 ;
18728 int alloc2 = 0 ;
18729 octave_value_list _out;
18730 octave_value_list *_outp=&_out;
18731 octave_value _outv;
18732 PLINT result;
18733
18734 if (!SWIG_check_num_args("plSetOpt",args.length(),2,2,0)) {
18735 SWIG_fail;
18736 }
18737 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18738 if (!SWIG_IsOK(res1)) {
18739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetOpt" "', argument " "1"" of type '" "char const *""'");
18740 }
18741 arg1 = (char *)(buf1);
18742 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
18743 if (!SWIG_IsOK(res2)) {
18744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetOpt" "', argument " "2"" of type '" "char const *""'");
18745 }
18746 arg2 = (char *)(buf2);
18747 result = (PLINT)plsetopt((char const *)arg1,(char const *)arg2);
18748 _outv = SWIG_From_int((int)(result));
18749 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18750 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18751 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
18752 fail:
18753 return _out;
18754 }
18755
18756
18757 SWIG_DEFUN( plsfam, _wrap_plsfam, _wrap_plsfam_texinfo ) {
18758 PLINT arg1 ;
18759 PLINT arg2 ;
18760 PLINT arg3 ;
18761 int val1 ;
18762 int ecode1 = 0 ;
18763 int val2 ;
18764 int ecode2 = 0 ;
18765 int val3 ;
18766 int ecode3 = 0 ;
18767 octave_value_list _out;
18768 octave_value_list *_outp=&_out;
18769 octave_value _outv;
18770
18771 if (!SWIG_check_num_args("plsfam",args.length(),3,3,0)) {
18772 SWIG_fail;
18773 }
18774 ecode1 = SWIG_AsVal_int(args(0), &val1);
18775 if (!SWIG_IsOK(ecode1)) {
18776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfam" "', argument " "1"" of type '" "PLINT""'");
18777 }
18778 arg1 = (PLINT)(val1);
18779 ecode2 = SWIG_AsVal_int(args(1), &val2);
18780 if (!SWIG_IsOK(ecode2)) {
18781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfam" "', argument " "2"" of type '" "PLINT""'");
18782 }
18783 arg2 = (PLINT)(val2);
18784 ecode3 = SWIG_AsVal_int(args(2), &val3);
18785 if (!SWIG_IsOK(ecode3)) {
18786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfam" "', argument " "3"" of type '" "PLINT""'");
18787 }
18788 arg3 = (PLINT)(val3);
18789 plsfam(arg1,arg2,arg3);
18790 _outv = octave_value();
18791 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18792 fail:
18793 return _out;
18794 }
18795
18796
18797 SWIG_DEFUN( plsfci, _wrap_plsfci, _wrap_plsfci_texinfo ) {
18798 PLUNICODE arg1 ;
18799 unsigned int val1 ;
18800 int ecode1 = 0 ;
18801 octave_value_list _out;
18802 octave_value_list *_outp=&_out;
18803 octave_value _outv;
18804
18805 if (!SWIG_check_num_args("plsfci",args.length(),1,1,0)) {
18806 SWIG_fail;
18807 }
18808 ecode1 = SWIG_AsVal_unsigned_SS_int(args(0), &val1);
18809 if (!SWIG_IsOK(ecode1)) {
18810 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfci" "', argument " "1"" of type '" "PLUNICODE""'");
18811 }
18812 arg1 = (PLUNICODE)(val1);
18813 plsfci(arg1);
18814 _outv = octave_value();
18815 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18816 fail:
18817 return _out;
18818 }
18819
18820
18821 SWIG_DEFUN( plsfnam, _wrap_plsfnam, _wrap_plsfnam_texinfo ) {
18822 char *arg1 = (char *) 0 ;
18823 int res1 ;
18824 char *buf1 = 0 ;
18825 int alloc1 = 0 ;
18826 octave_value_list _out;
18827 octave_value_list *_outp=&_out;
18828 octave_value _outv;
18829
18830 if (!SWIG_check_num_args("plsfnam",args.length(),1,1,0)) {
18831 SWIG_fail;
18832 }
18833 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
18834 if (!SWIG_IsOK(res1)) {
18835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plsfnam" "', argument " "1"" of type '" "char const *""'");
18836 }
18837 arg1 = (char *)(buf1);
18838 plsfnam((char const *)arg1);
18839 _outv = octave_value();
18840 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18841 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
18842 fail:
18843 return _out;
18844 }
18845
18846
18847 SWIG_DEFUN( plsfont, _wrap_plsfont, _wrap_plsfont_texinfo ) {
18848 PLINT arg1 ;
18849 PLINT arg2 ;
18850 PLINT arg3 ;
18851 int val1 ;
18852 int ecode1 = 0 ;
18853 int val2 ;
18854 int ecode2 = 0 ;
18855 int val3 ;
18856 int ecode3 = 0 ;
18857 octave_value_list _out;
18858 octave_value_list *_outp=&_out;
18859 octave_value _outv;
18860
18861 if (!SWIG_check_num_args("plsfont",args.length(),3,3,0)) {
18862 SWIG_fail;
18863 }
18864 ecode1 = SWIG_AsVal_int(args(0), &val1);
18865 if (!SWIG_IsOK(ecode1)) {
18866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsfont" "', argument " "1"" of type '" "PLINT""'");
18867 }
18868 arg1 = (PLINT)(val1);
18869 ecode2 = SWIG_AsVal_int(args(1), &val2);
18870 if (!SWIG_IsOK(ecode2)) {
18871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsfont" "', argument " "2"" of type '" "PLINT""'");
18872 }
18873 arg2 = (PLINT)(val2);
18874 ecode3 = SWIG_AsVal_int(args(2), &val3);
18875 if (!SWIG_IsOK(ecode3)) {
18876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsfont" "', argument " "3"" of type '" "PLINT""'");
18877 }
18878 arg3 = (PLINT)(val3);
18879 plsfont(arg1,arg2,arg3);
18880 _outv = octave_value();
18881 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18882 fail:
18883 return _out;
18884 }
18885
18886
18887 SWIG_DEFUN( plslabelfunc, _wrap_plslabelfunc, _wrap_plslabelfunc_texinfo ) {
18888 label_func arg1 = (label_func) 0 ;
18889 PLPointer arg2 = (PLPointer) 0 ;
18890 int res2 ;
18891 octave_value_list _out;
18892 octave_value_list *_outp=&_out;
18893 octave_value _outv;
18894
18895 if (!SWIG_check_num_args("plslabelfunc",args.length(),2,2,0)) {
18896 SWIG_fail;
18897 }
18898 {
18899 octave_value obj = args(0);
18900 if ( !obj.is_empty() )
18901 {
18902 if ( obj.is_function_handle() || obj.is_inline_function() )
18903 {
18904 fcnLabelFunc = obj.function_value();
18905 }
18906 else if ( obj.is_string() )
18907 {
18908 nameLabelFunc = obj.string_value();
18909 fcnLabelFunc = NULL;
18910 }
18911 arg1 = labelfunc_octave;
18912 }
18913 else
18914 {
18915 arg1 = NULL;
18916 }
18917 }
18918 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
18919 if (!SWIG_IsOK(res2)) {
18920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plslabelfunc" "', argument " "2"" of type '" "PLPointer""'");
18921 }
18922 plslabelfunc(arg1,arg2);
18923 _outv = octave_value();
18924 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18925 fail:
18926 return _out;
18927 }
18928
18929
18930 SWIG_DEFUN( plsmaj, _wrap_plsmaj, _wrap_plsmaj_texinfo ) {
18931 PLFLT arg1 ;
18932 PLFLT arg2 ;
18933 double val1 ;
18934 int ecode1 = 0 ;
18935 double val2 ;
18936 int ecode2 = 0 ;
18937 octave_value_list _out;
18938 octave_value_list *_outp=&_out;
18939 octave_value _outv;
18940
18941 if (!SWIG_check_num_args("plsmaj",args.length(),2,2,0)) {
18942 SWIG_fail;
18943 }
18944 ecode1 = SWIG_AsVal_double(args(0), &val1);
18945 if (!SWIG_IsOK(ecode1)) {
18946 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmaj" "', argument " "1"" of type '" "PLFLT""'");
18947 }
18948 arg1 = (PLFLT)(val1);
18949 ecode2 = SWIG_AsVal_double(args(1), &val2);
18950 if (!SWIG_IsOK(ecode2)) {
18951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmaj" "', argument " "2"" of type '" "PLFLT""'");
18952 }
18953 arg2 = (PLFLT)(val2);
18954 plsmaj(arg1,arg2);
18955 _outv = octave_value();
18956 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18957 fail:
18958 return _out;
18959 }
18960
18961
18962 SWIG_DEFUN( plsmin, _wrap_plsmin, _wrap_plsmin_texinfo ) {
18963 PLFLT arg1 ;
18964 PLFLT arg2 ;
18965 double val1 ;
18966 int ecode1 = 0 ;
18967 double val2 ;
18968 int ecode2 = 0 ;
18969 octave_value_list _out;
18970 octave_value_list *_outp=&_out;
18971 octave_value _outv;
18972
18973 if (!SWIG_check_num_args("plsmin",args.length(),2,2,0)) {
18974 SWIG_fail;
18975 }
18976 ecode1 = SWIG_AsVal_double(args(0), &val1);
18977 if (!SWIG_IsOK(ecode1)) {
18978 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsmin" "', argument " "1"" of type '" "PLFLT""'");
18979 }
18980 arg1 = (PLFLT)(val1);
18981 ecode2 = SWIG_AsVal_double(args(1), &val2);
18982 if (!SWIG_IsOK(ecode2)) {
18983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsmin" "', argument " "2"" of type '" "PLFLT""'");
18984 }
18985 arg2 = (PLFLT)(val2);
18986 plsmin(arg1,arg2);
18987 _outv = octave_value();
18988 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
18989 fail:
18990 return _out;
18991 }
18992
18993
18994 SWIG_DEFUN( plsori, _wrap_plsori, _wrap_plsori_texinfo ) {
18995 PLINT arg1 ;
18996 int val1 ;
18997 int ecode1 = 0 ;
18998 octave_value_list _out;
18999 octave_value_list *_outp=&_out;
19000 octave_value _outv;
19001
19002 if (!SWIG_check_num_args("plsori",args.length(),1,1,0)) {
19003 SWIG_fail;
19004 }
19005 ecode1 = SWIG_AsVal_int(args(0), &val1);
19006 if (!SWIG_IsOK(ecode1)) {
19007 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsori" "', argument " "1"" of type '" "PLINT""'");
19008 }
19009 arg1 = (PLINT)(val1);
19010 plsori(arg1);
19011 _outv = octave_value();
19012 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19013 fail:
19014 return _out;
19015 }
19016
19017
19018 SWIG_DEFUN( plspage, _wrap_plspage, _wrap_plspage_texinfo ) {
19019 PLFLT arg1 ;
19020 PLFLT arg2 ;
19021 PLINT arg3 ;
19022 PLINT arg4 ;
19023 PLINT arg5 ;
19024 PLINT arg6 ;
19025 double val1 ;
19026 int ecode1 = 0 ;
19027 double val2 ;
19028 int ecode2 = 0 ;
19029 int val3 ;
19030 int ecode3 = 0 ;
19031 int val4 ;
19032 int ecode4 = 0 ;
19033 int val5 ;
19034 int ecode5 = 0 ;
19035 int val6 ;
19036 int ecode6 = 0 ;
19037 octave_value_list _out;
19038 octave_value_list *_outp=&_out;
19039 octave_value _outv;
19040
19041 if (!SWIG_check_num_args("plspage",args.length(),6,6,0)) {
19042 SWIG_fail;
19043 }
19044 ecode1 = SWIG_AsVal_double(args(0), &val1);
19045 if (!SWIG_IsOK(ecode1)) {
19046 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspage" "', argument " "1"" of type '" "PLFLT""'");
19047 }
19048 arg1 = (PLFLT)(val1);
19049 ecode2 = SWIG_AsVal_double(args(1), &val2);
19050 if (!SWIG_IsOK(ecode2)) {
19051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspage" "', argument " "2"" of type '" "PLFLT""'");
19052 }
19053 arg2 = (PLFLT)(val2);
19054 ecode3 = SWIG_AsVal_int(args(2), &val3);
19055 if (!SWIG_IsOK(ecode3)) {
19056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plspage" "', argument " "3"" of type '" "PLINT""'");
19057 }
19058 arg3 = (PLINT)(val3);
19059 ecode4 = SWIG_AsVal_int(args(3), &val4);
19060 if (!SWIG_IsOK(ecode4)) {
19061 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plspage" "', argument " "4"" of type '" "PLINT""'");
19062 }
19063 arg4 = (PLINT)(val4);
19064 ecode5 = SWIG_AsVal_int(args(4), &val5);
19065 if (!SWIG_IsOK(ecode5)) {
19066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plspage" "', argument " "5"" of type '" "PLINT""'");
19067 }
19068 arg5 = (PLINT)(val5);
19069 ecode6 = SWIG_AsVal_int(args(5), &val6);
19070 if (!SWIG_IsOK(ecode6)) {
19071 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plspage" "', argument " "6"" of type '" "PLINT""'");
19072 }
19073 arg6 = (PLINT)(val6);
19074 plspage(arg1,arg2,arg3,arg4,arg5,arg6);
19075 _outv = octave_value();
19076 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19077 fail:
19078 return _out;
19079 }
19080
19081
19082 SWIG_DEFUN( plspal0, _wrap_plspal0, _wrap_plspal0_texinfo ) {
19083 char *arg1 = (char *) 0 ;
19084 int res1 ;
19085 char *buf1 = 0 ;
19086 int alloc1 = 0 ;
19087 octave_value_list _out;
19088 octave_value_list *_outp=&_out;
19089 octave_value _outv;
19090
19091 if (!SWIG_check_num_args("plspal0",args.length(),1,1,0)) {
19092 SWIG_fail;
19093 }
19094 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19095 if (!SWIG_IsOK(res1)) {
19096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal0" "', argument " "1"" of type '" "char const *""'");
19097 }
19098 arg1 = (char *)(buf1);
19099 plspal0((char const *)arg1);
19100 _outv = octave_value();
19101 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19102 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19103 fail:
19104 return _out;
19105 }
19106
19107
19108 SWIG_DEFUN( plspal1, _wrap_plspal1, _wrap_plspal1_texinfo ) {
19109 char *arg1 = (char *) 0 ;
19110 PLBOOL arg2 ;
19111 int res1 ;
19112 char *buf1 = 0 ;
19113 int alloc1 = 0 ;
19114 int val2 ;
19115 int ecode2 = 0 ;
19116 octave_value_list _out;
19117 octave_value_list *_outp=&_out;
19118 octave_value _outv;
19119
19120 if (!SWIG_check_num_args("plspal1",args.length(),2,2,0)) {
19121 SWIG_fail;
19122 }
19123 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19124 if (!SWIG_IsOK(res1)) {
19125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plspal1" "', argument " "1"" of type '" "char const *""'");
19126 }
19127 arg1 = (char *)(buf1);
19128 ecode2 = SWIG_AsVal_int(args(1), &val2);
19129 if (!SWIG_IsOK(ecode2)) {
19130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plspal1" "', argument " "2"" of type '" "PLBOOL""'");
19131 }
19132 arg2 = (PLBOOL)(val2);
19133 plspal1((char const *)arg1,arg2);
19134 _outv = octave_value();
19135 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19136 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19137 fail:
19138 return _out;
19139 }
19140
19141
19142 SWIG_DEFUN( plspause, _wrap_plspause, _wrap_plspause_texinfo ) {
19143 PLBOOL arg1 ;
19144 int val1 ;
19145 int ecode1 = 0 ;
19146 octave_value_list _out;
19147 octave_value_list *_outp=&_out;
19148 octave_value _outv;
19149
19150 if (!SWIG_check_num_args("plspause",args.length(),1,1,0)) {
19151 SWIG_fail;
19152 }
19153 ecode1 = SWIG_AsVal_int(args(0), &val1);
19154 if (!SWIG_IsOK(ecode1)) {
19155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plspause" "', argument " "1"" of type '" "PLBOOL""'");
19156 }
19157 arg1 = (PLBOOL)(val1);
19158 plspause(arg1);
19159 _outv = octave_value();
19160 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19161 fail:
19162 return _out;
19163 }
19164
19165
19166 SWIG_DEFUN( plsstrm, _wrap_plsstrm, _wrap_plsstrm_texinfo ) {
19167 PLINT arg1 ;
19168 int val1 ;
19169 int ecode1 = 0 ;
19170 octave_value_list _out;
19171 octave_value_list *_outp=&_out;
19172 octave_value _outv;
19173
19174 if (!SWIG_check_num_args("plsstrm",args.length(),1,1,0)) {
19175 SWIG_fail;
19176 }
19177 ecode1 = SWIG_AsVal_int(args(0), &val1);
19178 if (!SWIG_IsOK(ecode1)) {
19179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsstrm" "', argument " "1"" of type '" "PLINT""'");
19180 }
19181 arg1 = (PLINT)(val1);
19182 plsstrm(arg1);
19183 _outv = octave_value();
19184 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19185 fail:
19186 return _out;
19187 }
19188
19189
19190 SWIG_DEFUN( plssub, _wrap_plssub, _wrap_plssub_texinfo ) {
19191 PLINT arg1 ;
19192 PLINT arg2 ;
19193 int val1 ;
19194 int ecode1 = 0 ;
19195 int val2 ;
19196 int ecode2 = 0 ;
19197 octave_value_list _out;
19198 octave_value_list *_outp=&_out;
19199 octave_value _outv;
19200
19201 if (!SWIG_check_num_args("plssub",args.length(),2,2,0)) {
19202 SWIG_fail;
19203 }
19204 ecode1 = SWIG_AsVal_int(args(0), &val1);
19205 if (!SWIG_IsOK(ecode1)) {
19206 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssub" "', argument " "1"" of type '" "PLINT""'");
19207 }
19208 arg1 = (PLINT)(val1);
19209 ecode2 = SWIG_AsVal_int(args(1), &val2);
19210 if (!SWIG_IsOK(ecode2)) {
19211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssub" "', argument " "2"" of type '" "PLINT""'");
19212 }
19213 arg2 = (PLINT)(val2);
19214 plssub(arg1,arg2);
19215 _outv = octave_value();
19216 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19217 fail:
19218 return _out;
19219 }
19220
19221
19222 SWIG_DEFUN( plssym, _wrap_plssym, _wrap_plssym_texinfo ) {
19223 PLFLT arg1 ;
19224 PLFLT arg2 ;
19225 double val1 ;
19226 int ecode1 = 0 ;
19227 double val2 ;
19228 int ecode2 = 0 ;
19229 octave_value_list _out;
19230 octave_value_list *_outp=&_out;
19231 octave_value _outv;
19232
19233 if (!SWIG_check_num_args("plssym",args.length(),2,2,0)) {
19234 SWIG_fail;
19235 }
19236 ecode1 = SWIG_AsVal_double(args(0), &val1);
19237 if (!SWIG_IsOK(ecode1)) {
19238 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plssym" "', argument " "1"" of type '" "PLFLT""'");
19239 }
19240 arg1 = (PLFLT)(val1);
19241 ecode2 = SWIG_AsVal_double(args(1), &val2);
19242 if (!SWIG_IsOK(ecode2)) {
19243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plssym" "', argument " "2"" of type '" "PLFLT""'");
19244 }
19245 arg2 = (PLFLT)(val2);
19246 plssym(arg1,arg2);
19247 _outv = octave_value();
19248 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19249 fail:
19250 return _out;
19251 }
19252
19253
19254 SWIG_DEFUN( plstar, _wrap_plstar, _wrap_plstar_texinfo ) {
19255 PLINT arg1 ;
19256 PLINT arg2 ;
19257 int val1 ;
19258 int ecode1 = 0 ;
19259 int val2 ;
19260 int ecode2 = 0 ;
19261 octave_value_list _out;
19262 octave_value_list *_outp=&_out;
19263 octave_value _outv;
19264
19265 if (!SWIG_check_num_args("plstar",args.length(),2,2,0)) {
19266 SWIG_fail;
19267 }
19268 ecode1 = SWIG_AsVal_int(args(0), &val1);
19269 if (!SWIG_IsOK(ecode1)) {
19270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstar" "', argument " "1"" of type '" "PLINT""'");
19271 }
19272 arg1 = (PLINT)(val1);
19273 ecode2 = SWIG_AsVal_int(args(1), &val2);
19274 if (!SWIG_IsOK(ecode2)) {
19275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstar" "', argument " "2"" of type '" "PLINT""'");
19276 }
19277 arg2 = (PLINT)(val2);
19278 plstar(arg1,arg2);
19279 _outv = octave_value();
19280 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19281 fail:
19282 return _out;
19283 }
19284
19285
19286 SWIG_DEFUN( plstart, _wrap_plstart, _wrap_plstart_texinfo ) {
19287 char *arg1 = (char *) 0 ;
19288 PLINT arg2 ;
19289 PLINT arg3 ;
19290 int res1 ;
19291 char *buf1 = 0 ;
19292 int alloc1 = 0 ;
19293 int val2 ;
19294 int ecode2 = 0 ;
19295 int val3 ;
19296 int ecode3 = 0 ;
19297 octave_value_list _out;
19298 octave_value_list *_outp=&_out;
19299 octave_value _outv;
19300
19301 if (!SWIG_check_num_args("plstart",args.length(),3,3,0)) {
19302 SWIG_fail;
19303 }
19304 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19305 if (!SWIG_IsOK(res1)) {
19306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plstart" "', argument " "1"" of type '" "char const *""'");
19307 }
19308 arg1 = (char *)(buf1);
19309 ecode2 = SWIG_AsVal_int(args(1), &val2);
19310 if (!SWIG_IsOK(ecode2)) {
19311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstart" "', argument " "2"" of type '" "PLINT""'");
19312 }
19313 arg2 = (PLINT)(val2);
19314 ecode3 = SWIG_AsVal_int(args(2), &val3);
19315 if (!SWIG_IsOK(ecode3)) {
19316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstart" "', argument " "3"" of type '" "PLINT""'");
19317 }
19318 arg3 = (PLINT)(val3);
19319 plstart((char const *)arg1,arg2,arg3);
19320 _outv = octave_value();
19321 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19322 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19323 fail:
19324 return _out;
19325 }
19326
19327
19328 SWIG_DEFUN( plstransform, _wrap_plstransform, _wrap_plstransform_texinfo ) {
19329 ct_func arg1 = (ct_func) 0 ;
19330 PLPointer arg2 = (PLPointer) 0 ;
19331 int res2 ;
19332 octave_value_list _out;
19333 octave_value_list *_outp=&_out;
19334 octave_value _outv;
19335
19336 if (!SWIG_check_num_args("plstransform",args.length(),2,2,0)) {
19337 SWIG_fail;
19338 }
19339 {
19340 octave_value obj = args(0);
19341 if ( !obj.is_empty() )
19342 {
19343 if ( obj.is_function_handle() || obj.is_inline_function() )
19344 {
19345 fcnCoordTrans = obj.function_value();
19346 }
19347 else if ( obj.is_string() )
19348 {
19349 nameCoordTrans = obj.string_value();
19350 fcnCoordTrans = NULL;
19351 }
19352 arg1 = ct_octave;
19353 }
19354 else
19355 {
19356 arg1 = NULL;
19357 }
19358 }
19359 res2 = SWIG_ConvertPtr(args(1),SWIG_as_voidptrptr(&arg2), 0, 0);
19360 if (!SWIG_IsOK(res2)) {
19361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plstransform" "', argument " "2"" of type '" "PLPointer""'");
19362 }
19363 plstransform(arg1,arg2);
19364 _outv = octave_value();
19365 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19366 fail:
19367 return _out;
19368 }
19369
19370
19371 SWIG_DEFUN( plstring, _wrap_plstring, _wrap_plstring_texinfo ) {
19372 PLINT arg1 ;
19373 PLFLT *arg2 = (PLFLT *) 0 ;
19374 PLFLT *arg3 = (PLFLT *) 0 ;
19375 char *arg4 = (char *) 0 ;
19376 Matrix temp1 ;
19377 Matrix temp3 ;
19378 int res4 ;
19379 char *buf4 = 0 ;
19380 int alloc4 = 0 ;
19381 octave_value_list _out;
19382 octave_value_list *_outp=&_out;
19383 octave_value _outv;
19384
19385 if (!SWIG_check_num_args("plstring",args.length(),3,3,0)) {
19386 SWIG_fail;
19387 }
19388 {
19389 if ( _n_dims( args(0) ) > 1 )
19390 {
19391 error( "argument must be a scalar or vector" ); SWIG_fail;
19392 }
19393 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19394 temp1 = args(0).matrix_value();
19395 arg2 = &temp1( 0, 0 );
19396 }
19397 {
19398 if ( _n_dims( args(1) ) > 1 )
19399 {
19400 error( "argument must be a scalar or vector" ); SWIG_fail;
19401 }
19402 if ( _dim( args(1), 0 ) != Alen )
19403 {
19404 error( "argument vectors must be same length" ); SWIG_fail;
19405 }
19406 temp3 = args(1).matrix_value();
19407 arg3 = &temp3( 0, 0 );
19408 }
19409 res4 = SWIG_AsCharPtrAndSize(args(2), &buf4, NULL, &alloc4);
19410 if (!SWIG_IsOK(res4)) {
19411 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plstring" "', argument " "4"" of type '" "char const *""'");
19412 }
19413 arg4 = (char *)(buf4);
19414 plstring(arg1,(double const *)arg2,(double const *)arg3,(char const *)arg4);
19415 _outv = octave_value();
19416 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19417 {
19418
19419 }
19420 {
19421
19422 }
19423 if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
19424 fail:
19425 return _out;
19426 }
19427
19428
19429 SWIG_DEFUN( plstring3, _wrap_plstring3, _wrap_plstring3_texinfo ) {
19430 PLINT arg1 ;
19431 PLFLT *arg2 = (PLFLT *) 0 ;
19432 PLFLT *arg3 = (PLFLT *) 0 ;
19433 PLFLT *arg4 = (PLFLT *) 0 ;
19434 char *arg5 = (char *) 0 ;
19435 Matrix temp1 ;
19436 Matrix temp3 ;
19437 Matrix temp4 ;
19438 int res5 ;
19439 char *buf5 = 0 ;
19440 int alloc5 = 0 ;
19441 octave_value_list _out;
19442 octave_value_list *_outp=&_out;
19443 octave_value _outv;
19444
19445 if (!SWIG_check_num_args("plstring3",args.length(),4,4,0)) {
19446 SWIG_fail;
19447 }
19448 {
19449 if ( _n_dims( args(0) ) > 1 )
19450 {
19451 error( "argument must be a scalar or vector" ); SWIG_fail;
19452 }
19453 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19454 temp1 = args(0).matrix_value();
19455 arg2 = &temp1( 0, 0 );
19456 }
19457 {
19458 if ( _n_dims( args(1) ) > 1 )
19459 {
19460 error( "argument must be a scalar or vector" ); SWIG_fail;
19461 }
19462 if ( _dim( args(1), 0 ) != Alen )
19463 {
19464 error( "argument vectors must be same length" ); SWIG_fail;
19465 }
19466 temp3 = args(1).matrix_value();
19467 arg3 = &temp3( 0, 0 );
19468 }
19469 {
19470 if ( _n_dims( args(2) ) > 1 )
19471 {
19472 error( "argument must be a scalar or vector" ); SWIG_fail;
19473 }
19474 if ( _dim( args(2), 0 ) != Alen )
19475 {
19476 error( "argument vectors must be same length" ); SWIG_fail;
19477 }
19478 temp4 = args(2).matrix_value();
19479 arg4 = &temp4( 0, 0 );
19480 }
19481 res5 = SWIG_AsCharPtrAndSize(args(3), &buf5, NULL, &alloc5);
19482 if (!SWIG_IsOK(res5)) {
19483 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plstring3" "', argument " "5"" of type '" "char const *""'");
19484 }
19485 arg5 = (char *)(buf5);
19486 plstring3(arg1,(double const *)arg2,(double const *)arg3,(double const *)arg4,(char const *)arg5);
19487 _outv = octave_value();
19488 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19489 {
19490
19491 }
19492 {
19493
19494 }
19495 {
19496
19497 }
19498 if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
19499 fail:
19500 return _out;
19501 }
19502
19503
19504 SWIG_DEFUN( plstripa, _wrap_plstripa, _wrap_plstripa_texinfo ) {
19505 PLINT arg1 ;
19506 PLINT arg2 ;
19507 PLFLT arg3 ;
19508 PLFLT arg4 ;
19509 int val1 ;
19510 int ecode1 = 0 ;
19511 int val2 ;
19512 int ecode2 = 0 ;
19513 double val3 ;
19514 int ecode3 = 0 ;
19515 double val4 ;
19516 int ecode4 = 0 ;
19517 octave_value_list _out;
19518 octave_value_list *_outp=&_out;
19519 octave_value _outv;
19520
19521 if (!SWIG_check_num_args("plstripa",args.length(),4,4,0)) {
19522 SWIG_fail;
19523 }
19524 ecode1 = SWIG_AsVal_int(args(0), &val1);
19525 if (!SWIG_IsOK(ecode1)) {
19526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripa" "', argument " "1"" of type '" "PLINT""'");
19527 }
19528 arg1 = (PLINT)(val1);
19529 ecode2 = SWIG_AsVal_int(args(1), &val2);
19530 if (!SWIG_IsOK(ecode2)) {
19531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plstripa" "', argument " "2"" of type '" "PLINT""'");
19532 }
19533 arg2 = (PLINT)(val2);
19534 ecode3 = SWIG_AsVal_double(args(2), &val3);
19535 if (!SWIG_IsOK(ecode3)) {
19536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plstripa" "', argument " "3"" of type '" "PLFLT""'");
19537 }
19538 arg3 = (PLFLT)(val3);
19539 ecode4 = SWIG_AsVal_double(args(3), &val4);
19540 if (!SWIG_IsOK(ecode4)) {
19541 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plstripa" "', argument " "4"" of type '" "PLFLT""'");
19542 }
19543 arg4 = (PLFLT)(val4);
19544 plstripa(arg1,arg2,arg3,arg4);
19545 _outv = octave_value();
19546 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19547 fail:
19548 return _out;
19549 }
19550
19551
19552 SWIG_DEFUN( plstripd, _wrap_plstripd, _wrap_plstripd_texinfo ) {
19553 PLINT arg1 ;
19554 int val1 ;
19555 int ecode1 = 0 ;
19556 octave_value_list _out;
19557 octave_value_list *_outp=&_out;
19558 octave_value _outv;
19559
19560 if (!SWIG_check_num_args("plstripd",args.length(),1,1,0)) {
19561 SWIG_fail;
19562 }
19563 ecode1 = SWIG_AsVal_int(args(0), &val1);
19564 if (!SWIG_IsOK(ecode1)) {
19565 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plstripd" "', argument " "1"" of type '" "PLINT""'");
19566 }
19567 arg1 = (PLINT)(val1);
19568 plstripd(arg1);
19569 _outv = octave_value();
19570 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19571 fail:
19572 return _out;
19573 }
19574
19575
19576 SWIG_DEFUN( plstyl, _wrap_plstyl, _wrap_plstyl_texinfo ) {
19577 PLINT arg1 ;
19578 PLINT *arg2 = (PLINT *) 0 ;
19579 PLINT *arg3 = (PLINT *) 0 ;
19580 Matrix temp1 ;
19581 Matrix temp3 ;
19582 octave_value_list _out;
19583 octave_value_list *_outp=&_out;
19584 octave_value _outv;
19585
19586 if (!SWIG_check_num_args("plstyl",args.length(),2,2,0)) {
19587 SWIG_fail;
19588 }
19589 {
19590 if ( _n_dims( args(0) ) > 1 )
19591 {
19592 error( "argument must be a scalar or vector" ); SWIG_fail;
19593 }
19594 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19595 arg2 = new PLINT[Alen];
19596 temp1 = args(0).matrix_value();
19597 _cvt_double_to( arg2, &temp1( 0, 0 ), Alen );
19598 }
19599 {
19600 if ( _n_dims( args(1) ) > 1 )
19601 {
19602 error( "argument must be a scalar or vector" ); SWIG_fail;
19603 }
19604 if ( _dim( args(1), 0 ) != Alen )
19605 {
19606 error( "argument vectors must be same length" ); SWIG_fail;
19607 }
19608 temp3 = args(1).matrix_value();
19609 arg3 = new PLINT[Alen];
19610 _cvt_double_to( arg3, &temp3( 0, 0 ), Alen );
19611 }
19612 plstyl(arg1,(int const *)arg2,(int const *)arg3);
19613 _outv = octave_value();
19614 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19615 {
19616 delete [] arg2;
19617 }
19618 {
19619 delete [] arg3;
19620 }
19621 fail:
19622 return _out;
19623 }
19624
19625
19626 SWIG_DEFUN( plsvect, _wrap_plsvect, _wrap_plsvect_texinfo ) {
19627 PLFLT *arg1 = (PLFLT *) 0 ;
19628 PLFLT *arg2 = (PLFLT *) 0 ;
19629 PLINT arg3 ;
19630 PLBOOL arg4 ;
19631 Matrix temp1 ;
19632 Matrix temp2 ;
19633 int val4 ;
19634 int ecode4 = 0 ;
19635 octave_value_list _out;
19636 octave_value_list *_outp=&_out;
19637 octave_value _outv;
19638
19639 if (!SWIG_check_num_args("plsvect",args.length(),3,3,0)) {
19640 SWIG_fail;
19641 }
19642 {
19643 if ( _n_dims( args(0) ) > 1 )
19644 {
19645 error( "argument must be a scalar or vector" ); SWIG_fail;
19646 }
19647 if ( !args(0).is_empty() )
19648 {
19649 Alen = (PLINT) ( _dim( args(0), 0 ) );
19650 temp1 = args(0).matrix_value();
19651 arg1 = &temp1( 0, 0 );
19652 }
19653 else
19654 {
19655 arg1 = NULL;
19656 Alen = 0;
19657 }
19658 }
19659 {
19660 if ( _n_dims( args(1) ) > 1 )
19661 {
19662 error( "argument must be a scalar or vector" ); SWIG_fail;
19663 }
19664 if ( !args(1).is_empty() )
19665 {
19666 if ( _dim( args(1), 0 ) != Alen )
19667 {
19668 error( "argument vectors must be same length" ); SWIG_fail;
19669 }
19670 temp2 = args(1).matrix_value();
19671 arg2 = &temp2( 0, 0 );
19672 arg3 = (PLINT) ( _dim( args(1), 0 ) );
19673 }
19674 else
19675 {
19676 arg2 = NULL;
19677 arg3 = 0;
19678 }
19679 }
19680 ecode4 = SWIG_AsVal_int(args(2), &val4);
19681 if (!SWIG_IsOK(ecode4)) {
19682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvect" "', argument " "4"" of type '" "PLBOOL""'");
19683 }
19684 arg4 = (PLBOOL)(val4);
19685 plsvect((double const *)arg1,(double const *)arg2,arg3,arg4);
19686 _outv = octave_value();
19687 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19688 {
19689
19690 }
19691 {
19692
19693 }
19694 fail:
19695 return _out;
19696 }
19697
19698
19699 SWIG_DEFUN( plsvpa, _wrap_plsvpa, _wrap_plsvpa_texinfo ) {
19700 PLFLT arg1 ;
19701 PLFLT arg2 ;
19702 PLFLT arg3 ;
19703 PLFLT arg4 ;
19704 double val1 ;
19705 int ecode1 = 0 ;
19706 double val2 ;
19707 int ecode2 = 0 ;
19708 double val3 ;
19709 int ecode3 = 0 ;
19710 double val4 ;
19711 int ecode4 = 0 ;
19712 octave_value_list _out;
19713 octave_value_list *_outp=&_out;
19714 octave_value _outv;
19715
19716 if (!SWIG_check_num_args("plsvpa",args.length(),4,4,0)) {
19717 SWIG_fail;
19718 }
19719 ecode1 = SWIG_AsVal_double(args(0), &val1);
19720 if (!SWIG_IsOK(ecode1)) {
19721 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsvpa" "', argument " "1"" of type '" "PLFLT""'");
19722 }
19723 arg1 = (PLFLT)(val1);
19724 ecode2 = SWIG_AsVal_double(args(1), &val2);
19725 if (!SWIG_IsOK(ecode2)) {
19726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsvpa" "', argument " "2"" of type '" "PLFLT""'");
19727 }
19728 arg2 = (PLFLT)(val2);
19729 ecode3 = SWIG_AsVal_double(args(2), &val3);
19730 if (!SWIG_IsOK(ecode3)) {
19731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plsvpa" "', argument " "3"" of type '" "PLFLT""'");
19732 }
19733 arg3 = (PLFLT)(val3);
19734 ecode4 = SWIG_AsVal_double(args(3), &val4);
19735 if (!SWIG_IsOK(ecode4)) {
19736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsvpa" "', argument " "4"" of type '" "PLFLT""'");
19737 }
19738 arg4 = (PLFLT)(val4);
19739 plsvpa(arg1,arg2,arg3,arg4);
19740 _outv = octave_value();
19741 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19742 fail:
19743 return _out;
19744 }
19745
19746
19747 SWIG_DEFUN( plsxax, _wrap_plsxax, _wrap_plsxax_texinfo ) {
19748 PLINT arg1 ;
19749 PLINT arg2 ;
19750 int val1 ;
19751 int ecode1 = 0 ;
19752 int val2 ;
19753 int ecode2 = 0 ;
19754 octave_value_list _out;
19755 octave_value_list *_outp=&_out;
19756 octave_value _outv;
19757
19758 if (!SWIG_check_num_args("plsxax",args.length(),2,2,0)) {
19759 SWIG_fail;
19760 }
19761 ecode1 = SWIG_AsVal_int(args(0), &val1);
19762 if (!SWIG_IsOK(ecode1)) {
19763 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsxax" "', argument " "1"" of type '" "PLINT""'");
19764 }
19765 arg1 = (PLINT)(val1);
19766 ecode2 = SWIG_AsVal_int(args(1), &val2);
19767 if (!SWIG_IsOK(ecode2)) {
19768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsxax" "', argument " "2"" of type '" "PLINT""'");
19769 }
19770 arg2 = (PLINT)(val2);
19771 plsxax(arg1,arg2);
19772 _outv = octave_value();
19773 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19774 fail:
19775 return _out;
19776 }
19777
19778
19779 SWIG_DEFUN( plsyax, _wrap_plsyax, _wrap_plsyax_texinfo ) {
19780 PLINT arg1 ;
19781 PLINT arg2 ;
19782 int val1 ;
19783 int ecode1 = 0 ;
19784 int val2 ;
19785 int ecode2 = 0 ;
19786 octave_value_list _out;
19787 octave_value_list *_outp=&_out;
19788 octave_value _outv;
19789
19790 if (!SWIG_check_num_args("plsyax",args.length(),2,2,0)) {
19791 SWIG_fail;
19792 }
19793 ecode1 = SWIG_AsVal_int(args(0), &val1);
19794 if (!SWIG_IsOK(ecode1)) {
19795 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plsyax" "', argument " "1"" of type '" "PLINT""'");
19796 }
19797 arg1 = (PLINT)(val1);
19798 ecode2 = SWIG_AsVal_int(args(1), &val2);
19799 if (!SWIG_IsOK(ecode2)) {
19800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plsyax" "', argument " "2"" of type '" "PLINT""'");
19801 }
19802 arg2 = (PLINT)(val2);
19803 plsyax(arg1,arg2);
19804 _outv = octave_value();
19805 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19806 fail:
19807 return _out;
19808 }
19809
19810
19811 SWIG_DEFUN( plsym, _wrap_plsym, _wrap_plsym_texinfo ) {
19812 PLINT arg1 ;
19813 PLFLT *arg2 = (PLFLT *) 0 ;
19814 PLFLT *arg3 = (PLFLT *) 0 ;
19815 PLINT arg4 ;
19816 Matrix temp1 ;
19817 Matrix temp3 ;
19818 int val4 ;
19819 int ecode4 = 0 ;
19820 octave_value_list _out;
19821 octave_value_list *_outp=&_out;
19822 octave_value _outv;
19823
19824 if (!SWIG_check_num_args("plsym",args.length(),3,3,0)) {
19825 SWIG_fail;
19826 }
19827 {
19828 if ( _n_dims( args(0) ) > 1 )
19829 {
19830 error( "argument must be a scalar or vector" ); SWIG_fail;
19831 }
19832 arg1 = Alen = (PLINT) ( _dim( args(0), 0 ) );
19833 temp1 = args(0).matrix_value();
19834 arg2 = &temp1( 0, 0 );
19835 }
19836 {
19837 if ( _n_dims( args(1) ) > 1 )
19838 {
19839 error( "argument must be a scalar or vector" ); SWIG_fail;
19840 }
19841 if ( _dim( args(1), 0 ) != Alen )
19842 {
19843 error( "argument vectors must be same length" ); SWIG_fail;
19844 }
19845 temp3 = args(1).matrix_value();
19846 arg3 = &temp3( 0, 0 );
19847 }
19848 ecode4 = SWIG_AsVal_int(args(2), &val4);
19849 if (!SWIG_IsOK(ecode4)) {
19850 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plsym" "', argument " "4"" of type '" "PLINT""'");
19851 }
19852 arg4 = (PLINT)(val4);
19853 plsym(arg1,(double const *)arg2,(double const *)arg3,arg4);
19854 _outv = octave_value();
19855 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19856 {
19857
19858 }
19859 {
19860
19861 }
19862 fail:
19863 return _out;
19864 }
19865
19866
19867 SWIG_DEFUN( plszax, _wrap_plszax, _wrap_plszax_texinfo ) {
19868 PLINT arg1 ;
19869 PLINT arg2 ;
19870 int val1 ;
19871 int ecode1 = 0 ;
19872 int val2 ;
19873 int ecode2 = 0 ;
19874 octave_value_list _out;
19875 octave_value_list *_outp=&_out;
19876 octave_value _outv;
19877
19878 if (!SWIG_check_num_args("plszax",args.length(),2,2,0)) {
19879 SWIG_fail;
19880 }
19881 ecode1 = SWIG_AsVal_int(args(0), &val1);
19882 if (!SWIG_IsOK(ecode1)) {
19883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plszax" "', argument " "1"" of type '" "PLINT""'");
19884 }
19885 arg1 = (PLINT)(val1);
19886 ecode2 = SWIG_AsVal_int(args(1), &val2);
19887 if (!SWIG_IsOK(ecode2)) {
19888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plszax" "', argument " "2"" of type '" "PLINT""'");
19889 }
19890 arg2 = (PLINT)(val2);
19891 plszax(arg1,arg2);
19892 _outv = octave_value();
19893 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19894 fail:
19895 return _out;
19896 }
19897
19898
19899 SWIG_DEFUN( pltext, _wrap_pltext, _wrap_pltext_texinfo ) {
19900 octave_value_list _out;
19901 octave_value_list *_outp=&_out;
19902 octave_value _outv;
19903
19904 if (!SWIG_check_num_args("pltext",args.length(),0,0,0)) {
19905 SWIG_fail;
19906 }
19907 pltext();
19908 _outv = octave_value();
19909 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19910 fail:
19911 return _out;
19912 }
19913
19914
19915 SWIG_DEFUN( pltimefmt, _wrap_pltimefmt, _wrap_pltimefmt_texinfo ) {
19916 char *arg1 = (char *) 0 ;
19917 int res1 ;
19918 char *buf1 = 0 ;
19919 int alloc1 = 0 ;
19920 octave_value_list _out;
19921 octave_value_list *_outp=&_out;
19922 octave_value _outv;
19923
19924 if (!SWIG_check_num_args("pltimefmt",args.length(),1,1,0)) {
19925 SWIG_fail;
19926 }
19927 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
19928 if (!SWIG_IsOK(res1)) {
19929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pltimefmt" "', argument " "1"" of type '" "char const *""'");
19930 }
19931 arg1 = (char *)(buf1);
19932 pltimefmt((char const *)arg1);
19933 _outv = octave_value();
19934 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19935 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
19936 fail:
19937 return _out;
19938 }
19939
19940
19941 SWIG_DEFUN( plvasp, _wrap_plvasp, _wrap_plvasp_texinfo ) {
19942 PLFLT arg1 ;
19943 double val1 ;
19944 int ecode1 = 0 ;
19945 octave_value_list _out;
19946 octave_value_list *_outp=&_out;
19947 octave_value _outv;
19948
19949 if (!SWIG_check_num_args("plvasp",args.length(),1,1,0)) {
19950 SWIG_fail;
19951 }
19952 ecode1 = SWIG_AsVal_double(args(0), &val1);
19953 if (!SWIG_IsOK(ecode1)) {
19954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvasp" "', argument " "1"" of type '" "PLFLT""'");
19955 }
19956 arg1 = (PLFLT)(val1);
19957 plvasp(arg1);
19958 _outv = octave_value();
19959 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
19960 fail:
19961 return _out;
19962 }
19963
19964
19965 SWIG_DEFUN( plvpas, _wrap_plvpas, _wrap_plvpas_texinfo ) {
19966 PLFLT arg1 ;
19967 PLFLT arg2 ;
19968 PLFLT arg3 ;
19969 PLFLT arg4 ;
19970 PLFLT arg5 ;
19971 double val1 ;
19972 int ecode1 = 0 ;
19973 double val2 ;
19974 int ecode2 = 0 ;
19975 double val3 ;
19976 int ecode3 = 0 ;
19977 double val4 ;
19978 int ecode4 = 0 ;
19979 double val5 ;
19980 int ecode5 = 0 ;
19981 octave_value_list _out;
19982 octave_value_list *_outp=&_out;
19983 octave_value _outv;
19984
19985 if (!SWIG_check_num_args("plvpas",args.length(),5,5,0)) {
19986 SWIG_fail;
19987 }
19988 ecode1 = SWIG_AsVal_double(args(0), &val1);
19989 if (!SWIG_IsOK(ecode1)) {
19990 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpas" "', argument " "1"" of type '" "PLFLT""'");
19991 }
19992 arg1 = (PLFLT)(val1);
19993 ecode2 = SWIG_AsVal_double(args(1), &val2);
19994 if (!SWIG_IsOK(ecode2)) {
19995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpas" "', argument " "2"" of type '" "PLFLT""'");
19996 }
19997 arg2 = (PLFLT)(val2);
19998 ecode3 = SWIG_AsVal_double(args(2), &val3);
19999 if (!SWIG_IsOK(ecode3)) {
20000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpas" "', argument " "3"" of type '" "PLFLT""'");
20001 }
20002 arg3 = (PLFLT)(val3);
20003 ecode4 = SWIG_AsVal_double(args(3), &val4);
20004 if (!SWIG_IsOK(ecode4)) {
20005 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpas" "', argument " "4"" of type '" "PLFLT""'");
20006 }
20007 arg4 = (PLFLT)(val4);
20008 ecode5 = SWIG_AsVal_double(args(4), &val5);
20009 if (!SWIG_IsOK(ecode5)) {
20010 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plvpas" "', argument " "5"" of type '" "PLFLT""'");
20011 }
20012 arg5 = (PLFLT)(val5);
20013 plvpas(arg1,arg2,arg3,arg4,arg5);
20014 _outv = octave_value();
20015 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20016 fail:
20017 return _out;
20018 }
20019
20020
20021 SWIG_DEFUN( plvpor, _wrap_plvpor, _wrap_plvpor_texinfo ) {
20022 PLFLT arg1 ;
20023 PLFLT arg2 ;
20024 PLFLT arg3 ;
20025 PLFLT arg4 ;
20026 double val1 ;
20027 int ecode1 = 0 ;
20028 double val2 ;
20029 int ecode2 = 0 ;
20030 double val3 ;
20031 int ecode3 = 0 ;
20032 double val4 ;
20033 int ecode4 = 0 ;
20034 octave_value_list _out;
20035 octave_value_list *_outp=&_out;
20036 octave_value _outv;
20037
20038 if (!SWIG_check_num_args("plvpor",args.length(),4,4,0)) {
20039 SWIG_fail;
20040 }
20041 ecode1 = SWIG_AsVal_double(args(0), &val1);
20042 if (!SWIG_IsOK(ecode1)) {
20043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plvpor" "', argument " "1"" of type '" "PLFLT""'");
20044 }
20045 arg1 = (PLFLT)(val1);
20046 ecode2 = SWIG_AsVal_double(args(1), &val2);
20047 if (!SWIG_IsOK(ecode2)) {
20048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plvpor" "', argument " "2"" of type '" "PLFLT""'");
20049 }
20050 arg2 = (PLFLT)(val2);
20051 ecode3 = SWIG_AsVal_double(args(2), &val3);
20052 if (!SWIG_IsOK(ecode3)) {
20053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plvpor" "', argument " "3"" of type '" "PLFLT""'");
20054 }
20055 arg3 = (PLFLT)(val3);
20056 ecode4 = SWIG_AsVal_double(args(3), &val4);
20057 if (!SWIG_IsOK(ecode4)) {
20058 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plvpor" "', argument " "4"" of type '" "PLFLT""'");
20059 }
20060 arg4 = (PLFLT)(val4);
20061 plvpor(arg1,arg2,arg3,arg4);
20062 _outv = octave_value();
20063 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20064 fail:
20065 return _out;
20066 }
20067
20068
20069 SWIG_DEFUN( plvsta, _wrap_plvsta, _wrap_plvsta_texinfo ) {
20070 octave_value_list _out;
20071 octave_value_list *_outp=&_out;
20072 octave_value _outv;
20073
20074 if (!SWIG_check_num_args("plvsta",args.length(),0,0,0)) {
20075 SWIG_fail;
20076 }
20077 plvsta();
20078 _outv = octave_value();
20079 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20080 fail:
20081 return _out;
20082 }
20083
20084
20085 SWIG_DEFUN( plw3d, _wrap_plw3d, _wrap_plw3d_texinfo ) {
20086 PLFLT arg1 ;
20087 PLFLT arg2 ;
20088 PLFLT arg3 ;
20089 PLFLT arg4 ;
20090 PLFLT arg5 ;
20091 PLFLT arg6 ;
20092 PLFLT arg7 ;
20093 PLFLT arg8 ;
20094 PLFLT arg9 ;
20095 PLFLT arg10 ;
20096 PLFLT arg11 ;
20097 double val1 ;
20098 int ecode1 = 0 ;
20099 double val2 ;
20100 int ecode2 = 0 ;
20101 double val3 ;
20102 int ecode3 = 0 ;
20103 double val4 ;
20104 int ecode4 = 0 ;
20105 double val5 ;
20106 int ecode5 = 0 ;
20107 double val6 ;
20108 int ecode6 = 0 ;
20109 double val7 ;
20110 int ecode7 = 0 ;
20111 double val8 ;
20112 int ecode8 = 0 ;
20113 double val9 ;
20114 int ecode9 = 0 ;
20115 double val10 ;
20116 int ecode10 = 0 ;
20117 double val11 ;
20118 int ecode11 = 0 ;
20119 octave_value_list _out;
20120 octave_value_list *_outp=&_out;
20121 octave_value _outv;
20122
20123 if (!SWIG_check_num_args("plw3d",args.length(),11,11,0)) {
20124 SWIG_fail;
20125 }
20126 ecode1 = SWIG_AsVal_double(args(0), &val1);
20127 if (!SWIG_IsOK(ecode1)) {
20128 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plw3d" "', argument " "1"" of type '" "PLFLT""'");
20129 }
20130 arg1 = (PLFLT)(val1);
20131 ecode2 = SWIG_AsVal_double(args(1), &val2);
20132 if (!SWIG_IsOK(ecode2)) {
20133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plw3d" "', argument " "2"" of type '" "PLFLT""'");
20134 }
20135 arg2 = (PLFLT)(val2);
20136 ecode3 = SWIG_AsVal_double(args(2), &val3);
20137 if (!SWIG_IsOK(ecode3)) {
20138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plw3d" "', argument " "3"" of type '" "PLFLT""'");
20139 }
20140 arg3 = (PLFLT)(val3);
20141 ecode4 = SWIG_AsVal_double(args(3), &val4);
20142 if (!SWIG_IsOK(ecode4)) {
20143 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plw3d" "', argument " "4"" of type '" "PLFLT""'");
20144 }
20145 arg4 = (PLFLT)(val4);
20146 ecode5 = SWIG_AsVal_double(args(4), &val5);
20147 if (!SWIG_IsOK(ecode5)) {
20148 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plw3d" "', argument " "5"" of type '" "PLFLT""'");
20149 }
20150 arg5 = (PLFLT)(val5);
20151 ecode6 = SWIG_AsVal_double(args(5), &val6);
20152 if (!SWIG_IsOK(ecode6)) {
20153 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plw3d" "', argument " "6"" of type '" "PLFLT""'");
20154 }
20155 arg6 = (PLFLT)(val6);
20156 ecode7 = SWIG_AsVal_double(args(6), &val7);
20157 if (!SWIG_IsOK(ecode7)) {
20158 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plw3d" "', argument " "7"" of type '" "PLFLT""'");
20159 }
20160 arg7 = (PLFLT)(val7);
20161 ecode8 = SWIG_AsVal_double(args(7), &val8);
20162 if (!SWIG_IsOK(ecode8)) {
20163 SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "plw3d" "', argument " "8"" of type '" "PLFLT""'");
20164 }
20165 arg8 = (PLFLT)(val8);
20166 ecode9 = SWIG_AsVal_double(args(8), &val9);
20167 if (!SWIG_IsOK(ecode9)) {
20168 SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "plw3d" "', argument " "9"" of type '" "PLFLT""'");
20169 }
20170 arg9 = (PLFLT)(val9);
20171 ecode10 = SWIG_AsVal_double(args(9), &val10);
20172 if (!SWIG_IsOK(ecode10)) {
20173 SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "plw3d" "', argument " "10"" of type '" "PLFLT""'");
20174 }
20175 arg10 = (PLFLT)(val10);
20176 ecode11 = SWIG_AsVal_double(args(10), &val11);
20177 if (!SWIG_IsOK(ecode11)) {
20178 SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "plw3d" "', argument " "11"" of type '" "PLFLT""'");
20179 }
20180 arg11 = (PLFLT)(val11);
20181 plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
20182 _outv = octave_value();
20183 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20184 fail:
20185 return _out;
20186 }
20187
20188
20189 SWIG_DEFUN( plwidth, _wrap_plwidth, _wrap_plwidth_texinfo ) {
20190 PLINT arg1 ;
20191 int val1 ;
20192 int ecode1 = 0 ;
20193 octave_value_list _out;
20194 octave_value_list *_outp=&_out;
20195 octave_value _outv;
20196
20197 if (!SWIG_check_num_args("plwidth",args.length(),1,1,0)) {
20198 SWIG_fail;
20199 }
20200 ecode1 = SWIG_AsVal_int(args(0), &val1);
20201 if (!SWIG_IsOK(ecode1)) {
20202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwidth" "', argument " "1"" of type '" "PLINT""'");
20203 }
20204 arg1 = (PLINT)(val1);
20205 plwidth(arg1);
20206 _outv = octave_value();
20207 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20208 fail:
20209 return _out;
20210 }
20211
20212
20213 SWIG_DEFUN( plwind, _wrap_plwind, _wrap_plwind_texinfo ) {
20214 PLFLT arg1 ;
20215 PLFLT arg2 ;
20216 PLFLT arg3 ;
20217 PLFLT arg4 ;
20218 double val1 ;
20219 int ecode1 = 0 ;
20220 double val2 ;
20221 int ecode2 = 0 ;
20222 double val3 ;
20223 int ecode3 = 0 ;
20224 double val4 ;
20225 int ecode4 = 0 ;
20226 octave_value_list _out;
20227 octave_value_list *_outp=&_out;
20228 octave_value _outv;
20229
20230 if (!SWIG_check_num_args("plwind",args.length(),4,4,0)) {
20231 SWIG_fail;
20232 }
20233 ecode1 = SWIG_AsVal_double(args(0), &val1);
20234 if (!SWIG_IsOK(ecode1)) {
20235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plwind" "', argument " "1"" of type '" "PLFLT""'");
20236 }
20237 arg1 = (PLFLT)(val1);
20238 ecode2 = SWIG_AsVal_double(args(1), &val2);
20239 if (!SWIG_IsOK(ecode2)) {
20240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plwind" "', argument " "2"" of type '" "PLFLT""'");
20241 }
20242 arg2 = (PLFLT)(val2);
20243 ecode3 = SWIG_AsVal_double(args(2), &val3);
20244 if (!SWIG_IsOK(ecode3)) {
20245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plwind" "', argument " "3"" of type '" "PLFLT""'");
20246 }
20247 arg3 = (PLFLT)(val3);
20248 ecode4 = SWIG_AsVal_double(args(3), &val4);
20249 if (!SWIG_IsOK(ecode4)) {
20250 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plwind" "', argument " "4"" of type '" "PLFLT""'");
20251 }
20252 arg4 = (PLFLT)(val4);
20253 plwind(arg1,arg2,arg3,arg4);
20254 _outv = octave_value();
20255 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20256 fail:
20257 return _out;
20258 }
20259
20260
20261 SWIG_DEFUN( plxormod, _wrap_plxormod, _wrap_plxormod_texinfo ) {
20262 PLBOOL arg1 ;
20263 PLBOOL *arg2 = (PLBOOL *) 0 ;
20264 int val1 ;
20265 int ecode1 = 0 ;
20266 PLBOOL temp2 ;
20267 int res2 = SWIG_TMPOBJ ;
20268 octave_value_list _out;
20269 octave_value_list *_outp=&_out;
20270 octave_value _outv;
20271
20272 arg2 = &temp2;
20273 if (!SWIG_check_num_args("plxormod",args.length(),1,1,0)) {
20274 SWIG_fail;
20275 }
20276 ecode1 = SWIG_AsVal_int(args(0), &val1);
20277 if (!SWIG_IsOK(ecode1)) {
20278 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "plxormod" "', argument " "1"" of type '" "PLBOOL""'");
20279 }
20280 arg1 = (PLBOOL)(val1);
20281 plxormod(arg1,arg2);
20282 _outv = octave_value();
20283 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20284 if (SWIG_IsTmpObj(res2)) {
20285 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_From_int((*arg2)));
20286 } else {
20287 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20288 _outp = SWIG_Octave_AppendOutput(_outp, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
20289 }
20290 fail:
20291 return _out;
20292 }
20293
20294
20295 SWIG_DEFUN( plmap, _wrap_plmap, _wrap_plmap_texinfo ) {
20296 mapform_func arg1 = (mapform_func) 0 ;
20297 char *arg2 = (char *) 0 ;
20298 PLFLT arg3 ;
20299 PLFLT arg4 ;
20300 PLFLT arg5 ;
20301 PLFLT arg6 ;
20302 int res2 ;
20303 char *buf2 = 0 ;
20304 int alloc2 = 0 ;
20305 double val3 ;
20306 int ecode3 = 0 ;
20307 double val4 ;
20308 int ecode4 = 0 ;
20309 double val5 ;
20310 int ecode5 = 0 ;
20311 double val6 ;
20312 int ecode6 = 0 ;
20313 octave_value_list _out;
20314 octave_value_list *_outp=&_out;
20315 octave_value _outv;
20316
20317 if (!SWIG_check_num_args("plmap",args.length(),6,6,0)) {
20318 SWIG_fail;
20319 }
20320 {
20321 octave_value obj = args(0);
20322 if ( !obj.is_empty() )
20323 {
20324 if ( obj.is_function_handle() || obj.is_inline_function() )
20325 {
20326 fcnMapForm = obj.function_value();
20327 }
20328 else if ( obj.is_string() )
20329 {
20330 nameMapForm = obj.string_value();
20331 fcnMapForm = NULL;
20332 }
20333 arg1 = mapform_octave;
20334 }
20335 else
20336 {
20337 arg1 = NULL;
20338 }
20339 }
20340 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20341 if (!SWIG_IsOK(res2)) {
20342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plmap" "', argument " "2"" of type '" "char const *""'");
20343 }
20344 arg2 = (char *)(buf2);
20345 ecode3 = SWIG_AsVal_double(args(2), &val3);
20346 if (!SWIG_IsOK(ecode3)) {
20347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmap" "', argument " "3"" of type '" "PLFLT""'");
20348 }
20349 arg3 = (PLFLT)(val3);
20350 ecode4 = SWIG_AsVal_double(args(3), &val4);
20351 if (!SWIG_IsOK(ecode4)) {
20352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmap" "', argument " "4"" of type '" "PLFLT""'");
20353 }
20354 arg4 = (PLFLT)(val4);
20355 ecode5 = SWIG_AsVal_double(args(4), &val5);
20356 if (!SWIG_IsOK(ecode5)) {
20357 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmap" "', argument " "5"" of type '" "PLFLT""'");
20358 }
20359 arg5 = (PLFLT)(val5);
20360 ecode6 = SWIG_AsVal_double(args(5), &val6);
20361 if (!SWIG_IsOK(ecode6)) {
20362 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmap" "', argument " "6"" of type '" "PLFLT""'");
20363 }
20364 arg6 = (PLFLT)(val6);
20365 plmap(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
20366 _outv = octave_value();
20367 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20368 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20369 fail:
20370 return _out;
20371 }
20372
20373
20374 SWIG_DEFUN( plmeridians, _wrap_plmeridians, _wrap_plmeridians_texinfo ) {
20375 mapform_func arg1 = (mapform_func) 0 ;
20376 PLFLT arg2 ;
20377 PLFLT arg3 ;
20378 PLFLT arg4 ;
20379 PLFLT arg5 ;
20380 PLFLT arg6 ;
20381 PLFLT arg7 ;
20382 double val2 ;
20383 int ecode2 = 0 ;
20384 double val3 ;
20385 int ecode3 = 0 ;
20386 double val4 ;
20387 int ecode4 = 0 ;
20388 double val5 ;
20389 int ecode5 = 0 ;
20390 double val6 ;
20391 int ecode6 = 0 ;
20392 double val7 ;
20393 int ecode7 = 0 ;
20394 octave_value_list _out;
20395 octave_value_list *_outp=&_out;
20396 octave_value _outv;
20397
20398 if (!SWIG_check_num_args("plmeridians",args.length(),7,7,0)) {
20399 SWIG_fail;
20400 }
20401 {
20402 octave_value obj = args(0);
20403 if ( !obj.is_empty() )
20404 {
20405 if ( obj.is_function_handle() || obj.is_inline_function() )
20406 {
20407 fcnMapForm = obj.function_value();
20408 }
20409 else if ( obj.is_string() )
20410 {
20411 nameMapForm = obj.string_value();
20412 fcnMapForm = NULL;
20413 }
20414 arg1 = mapform_octave;
20415 }
20416 else
20417 {
20418 arg1 = NULL;
20419 }
20420 }
20421 ecode2 = SWIG_AsVal_double(args(1), &val2);
20422 if (!SWIG_IsOK(ecode2)) {
20423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plmeridians" "', argument " "2"" of type '" "PLFLT""'");
20424 }
20425 arg2 = (PLFLT)(val2);
20426 ecode3 = SWIG_AsVal_double(args(2), &val3);
20427 if (!SWIG_IsOK(ecode3)) {
20428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "plmeridians" "', argument " "3"" of type '" "PLFLT""'");
20429 }
20430 arg3 = (PLFLT)(val3);
20431 ecode4 = SWIG_AsVal_double(args(3), &val4);
20432 if (!SWIG_IsOK(ecode4)) {
20433 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plmeridians" "', argument " "4"" of type '" "PLFLT""'");
20434 }
20435 arg4 = (PLFLT)(val4);
20436 ecode5 = SWIG_AsVal_double(args(4), &val5);
20437 if (!SWIG_IsOK(ecode5)) {
20438 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "plmeridians" "', argument " "5"" of type '" "PLFLT""'");
20439 }
20440 arg5 = (PLFLT)(val5);
20441 ecode6 = SWIG_AsVal_double(args(5), &val6);
20442 if (!SWIG_IsOK(ecode6)) {
20443 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plmeridians" "', argument " "6"" of type '" "PLFLT""'");
20444 }
20445 arg6 = (PLFLT)(val6);
20446 ecode7 = SWIG_AsVal_double(args(6), &val7);
20447 if (!SWIG_IsOK(ecode7)) {
20448 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "plmeridians" "', argument " "7"" of type '" "PLFLT""'");
20449 }
20450 arg7 = (PLFLT)(val7);
20451 plmeridians(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
20452 _outv = octave_value();
20453 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20454 fail:
20455 return _out;
20456 }
20457
20458
20459 SWIG_DEFUN( plClearOpts, _wrap_plClearOpts, std::string() ) {
20460 octave_value_list _out;
20461 octave_value_list *_outp=&_out;
20462 octave_value _outv;
20463
20464 if (!SWIG_check_num_args("plClearOpts",args.length(),0,0,0)) {
20465 SWIG_fail;
20466 }
20467 plClearOpts();
20468 _outv = octave_value();
20469 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20470 fail:
20471 return _out;
20472 }
20473
20474
20475 SWIG_DEFUN( plResetOpts, _wrap_plResetOpts, std::string() ) {
20476 octave_value_list _out;
20477 octave_value_list *_outp=&_out;
20478 octave_value _outv;
20479
20480 if (!SWIG_check_num_args("plResetOpts",args.length(),0,0,0)) {
20481 SWIG_fail;
20482 }
20483 plResetOpts();
20484 _outv = octave_value();
20485 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20486 fail:
20487 return _out;
20488 }
20489
20490
20491 SWIG_DEFUN( plSetUsage, _wrap_plSetUsage, std::string() ) {
20492 char *arg1 = (char *) 0 ;
20493 char *arg2 = (char *) 0 ;
20494 int res1 ;
20495 char *buf1 = 0 ;
20496 int alloc1 = 0 ;
20497 int res2 ;
20498 char *buf2 = 0 ;
20499 int alloc2 = 0 ;
20500 octave_value_list _out;
20501 octave_value_list *_outp=&_out;
20502 octave_value _outv;
20503
20504 if (!SWIG_check_num_args("plSetUsage",args.length(),2,2,0)) {
20505 SWIG_fail;
20506 }
20507 res1 = SWIG_AsCharPtrAndSize(args(0), &buf1, NULL, &alloc1);
20508 if (!SWIG_IsOK(res1)) {
20509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plSetUsage" "', argument " "1"" of type '" "char const *""'");
20510 }
20511 arg1 = (char *)(buf1);
20512 res2 = SWIG_AsCharPtrAndSize(args(1), &buf2, NULL, &alloc2);
20513 if (!SWIG_IsOK(res2)) {
20514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plSetUsage" "', argument " "2"" of type '" "char const *""'");
20515 }
20516 arg2 = (char *)(buf2);
20517 plSetUsage((char const *)arg1,(char const *)arg2);
20518 _outv = octave_value();
20519 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20520 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
20521 if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
20522 fail:
20523 return _out;
20524 }
20525
20526
20527 SWIG_DEFUN( plOptUsage, _wrap_plOptUsage, std::string() ) {
20528 octave_value_list _out;
20529 octave_value_list *_outp=&_out;
20530 octave_value _outv;
20531
20532 if (!SWIG_check_num_args("plOptUsage",args.length(),0,0,0)) {
20533 SWIG_fail;
20534 }
20535 plOptUsage();
20536 _outv = octave_value();
20537 if (_outv.is_defined()) _outp = SWIG_Octave_AppendOutput(_outp, _outv);
20538 fail:
20539 return _out;
20540 }
20541
20542
20543
20544 static const struct swig_octave_member swig_globals[] = {
20545 {"testppchar",_wrap_testppchar,0,0,2,0},
20546 {"plGetCursor",_wrap_plGetCursor,0,0,2,0},
20547 {"plTranslateCursor",_wrap_plTranslateCursor,0,0,2,0},
20548 {"plstripc",_wrap_plstripc,0,0,2,0},
20549 {"plcont",_wrap_plcont,0,0,2,0},
20550 {"plcont0",_wrap_plcont0,0,0,2,0},
20551 {"plcont1",_wrap_plcont1,0,0,2,0},
20552 {"plcont2",_wrap_plcont2,0,0,2,0},
20553 {"plcont2p",_wrap_plcont2p,0,0,2,0},
20554 {"plgriddata",_wrap_plgriddata,0,0,2,0},
20555 {"plmesh",_wrap_plmesh,0,0,2,0},
20556 {"plmeshc",_wrap_plmeshc,0,0,2,0},
20557 {"plot3d",_wrap_plot3d,0,0,2,0},
20558 {"plot3dc",_wrap_plot3dc,0,0,2,0},
20559 {"plsurf3d",_wrap_plsurf3d,0,0,2,0},
20560 {"plshade",_wrap_plshade,0,0,2,0},
20561 {"plshade1",_wrap_plshade1,0,0,2,0},
20562 {"plshade2",_wrap_plshade2,0,0,2,0},
20563 {"plshades",_wrap_plshades,0,0,2,0},
20564 {"plshadesx",_wrap_plshadesx,0,0,2,0},
20565 {"plshades1",_wrap_plshades1,0,0,2,0},
20566 {"plshades2",_wrap_plshades2,0,0,2,0},
20567 {"plvect",_wrap_plvect,0,0,2,0},
20568 {"plvect1",_wrap_plvect1,0,0,2,0},
20569 {"plvect2",_wrap_plvect2,0,0,2,0},
20570 {"pplimage",_wrap_pplimage,0,0,2,0},
20571 {"plimagefr",_wrap_plimagefr,0,0,2,0},
20572 {"plimagefrx",_wrap_plimagefrx,0,0,2,0},
20573 {"plimagefr1",_wrap_plimagefr1,0,0,2,0},
20574 {"plimagefr2",_wrap_plimagefr2,0,0,2,0},
20575 {"plcolorbar",_wrap_plcolorbar,0,0,2,0},
20576 {"PLGraphicsIn_type_set",_wrap_PLGraphicsIn_type_set,0,0,2,0},
20577 {"PLGraphicsIn_type_get",_wrap_PLGraphicsIn_type_get,0,0,2,0},
20578 {"PLGraphicsIn_state_set",_wrap_PLGraphicsIn_state_set,0,0,2,0},
20579 {"PLGraphicsIn_state_get",_wrap_PLGraphicsIn_state_get,0,0,2,0},
20580 {"PLGraphicsIn_keysym_set",_wrap_PLGraphicsIn_keysym_set,0,0,2,0},
20581 {"PLGraphicsIn_keysym_get",_wrap_PLGraphicsIn_keysym_get,0,0,2,0},
20582 {"PLGraphicsIn_button_set",_wrap_PLGraphicsIn_button_set,0,0,2,0},
20583 {"PLGraphicsIn_button_get",_wrap_PLGraphicsIn_button_get,0,0,2,0},
20584 {"PLGraphicsIn_subwindow_set",_wrap_PLGraphicsIn_subwindow_set,0,0,2,0},
20585 {"PLGraphicsIn_subwindow_get",_wrap_PLGraphicsIn_subwindow_get,0,0,2,0},
20586 {"PLGraphicsIn_string_set",_wrap_PLGraphicsIn_string_set,0,0,2,0},
20587 {"PLGraphicsIn_string_get",_wrap_PLGraphicsIn_string_get,0,0,2,0},
20588 {"PLGraphicsIn_pX_set",_wrap_PLGraphicsIn_pX_set,0,0,2,0},
20589 {"PLGraphicsIn_pX_get",_wrap_PLGraphicsIn_pX_get,0,0,2,0},
20590 {"PLGraphicsIn_pY_set",_wrap_PLGraphicsIn_pY_set,0,0,2,0},
20591 {"PLGraphicsIn_pY_get",_wrap_PLGraphicsIn_pY_get,0,0,2,0},
20592 {"PLGraphicsIn_dX_set",_wrap_PLGraphicsIn_dX_set,0,0,2,0},
20593 {"PLGraphicsIn_dX_get",_wrap_PLGraphicsIn_dX_get,0,0,2,0},
20594 {"PLGraphicsIn_dY_set",_wrap_PLGraphicsIn_dY_set,0,0,2,0},
20595 {"PLGraphicsIn_dY_get",_wrap_PLGraphicsIn_dY_get,0,0,2,0},
20596 {"PLGraphicsIn_wX_set",_wrap_PLGraphicsIn_wX_set,0,0,2,0},
20597 {"PLGraphicsIn_wX_get",_wrap_PLGraphicsIn_wX_get,0,0,2,0},
20598 {"PLGraphicsIn_wY_set",_wrap_PLGraphicsIn_wY_set,0,0,2,0},
20599 {"PLGraphicsIn_wY_get",_wrap_PLGraphicsIn_wY_get,0,0,2,0},
20600 {"new_PLGraphicsIn",_wrap_new_PLGraphicsIn,0,0,2,0},
20601 {"delete_PLGraphicsIn",_wrap_delete_PLGraphicsIn,0,0,2,0},
20602 {"pl_setcontlabelformat",_wrap_pl_setcontlabelformat,0,0,2,_wrap_pl_setcontlabelformat_texinfo},
20603 {"pl_setcontlabelparam",_wrap_pl_setcontlabelparam,0,0,2,_wrap_pl_setcontlabelparam_texinfo},
20604 {"pladv",_wrap_pladv,0,0,2,_wrap_pladv_texinfo},
20605 {"plarc",_wrap_plarc,0,0,2,_wrap_plarc_texinfo},
20606 {"plaxes",_wrap_plaxes,0,0,2,_wrap_plaxes_texinfo},
20607 {"plbin",_wrap_plbin,0,0,2,_wrap_plbin_texinfo},
20608 {"plbtime",_wrap_plbtime,0,0,2,0},
20609 {"plbop",_wrap_plbop,0,0,2,_wrap_plbop_texinfo},
20610 {"plbox",_wrap_plbox,0,0,2,_wrap_plbox_texinfo},
20611 {"plbox3",_wrap_plbox3,0,0,2,_wrap_plbox3_texinfo},
20612 {"plcalc_world",_wrap_plcalc_world,0,0,2,_wrap_plcalc_world_texinfo},
20613 {"plclear",_wrap_plclear,0,0,2,_wrap_plclear_texinfo},
20614 {"plcol0",_wrap_plcol0,0,0,2,_wrap_plcol0_texinfo},
20615 {"plcol1",_wrap_plcol1,0,0,2,_wrap_plcol1_texinfo},
20616 {"plconfigtime",_wrap_plconfigtime,0,0,2,0},
20617 {"plctime",_wrap_plctime,0,0,2,0},
20618 {"plcpstrm",_wrap_plcpstrm,0,0,2,_wrap_plcpstrm_texinfo},
20619 {"plend",_wrap_plend,0,0,2,_wrap_plend_texinfo},
20620 {"plend1",_wrap_plend1,0,0,2,_wrap_plend1_texinfo},
20621 {"plenv",_wrap_plenv,0,0,2,_wrap_plenv_texinfo},
20622 {"plenv0",_wrap_plenv0,0,0,2,_wrap_plenv0_texinfo},
20623 {"pleop",_wrap_pleop,0,0,2,_wrap_pleop_texinfo},
20624 {"plerrx",_wrap_plerrx,0,0,2,_wrap_plerrx_texinfo},
20625 {"plerry",_wrap_plerry,0,0,2,_wrap_plerry_texinfo},
20626 {"plfamadv",_wrap_plfamadv,0,0,2,_wrap_plfamadv_texinfo},
20627 {"plfill",_wrap_plfill,0,0,2,_wrap_plfill_texinfo},
20628 {"plfill3",_wrap_plfill3,0,0,2,_wrap_plfill3_texinfo},
20629 {"plgradient",_wrap_plgradient,0,0,2,_wrap_plgradient_texinfo},
20630 {"plflush",_wrap_plflush,0,0,2,_wrap_plflush_texinfo},
20631 {"plfont",_wrap_plfont,0,0,2,_wrap_plfont_texinfo},
20632 {"plfontld",_wrap_plfontld,0,0,2,_wrap_plfontld_texinfo},
20633 {"plgchr",_wrap_plgchr,0,0,2,_wrap_plgchr_texinfo},
20634 {"plgcol0",_wrap_plgcol0,0,0,2,_wrap_plgcol0_texinfo},
20635 {"plgcol0a",_wrap_plgcol0a,0,0,2,_wrap_plgcol0a_texinfo},
20636 {"plgcolbg",_wrap_plgcolbg,0,0,2,_wrap_plgcolbg_texinfo},
20637 {"plgcolbga",_wrap_plgcolbga,0,0,2,_wrap_plgcolbga_texinfo},
20638 {"plgcompression",_wrap_plgcompression,0,0,2,_wrap_plgcompression_texinfo},
20639 {"plgdev",_wrap_plgdev,0,0,2,_wrap_plgdev_texinfo},
20640 {"plgdidev",_wrap_plgdidev,0,0,2,_wrap_plgdidev_texinfo},
20641 {"plgdiori",_wrap_plgdiori,0,0,2,_wrap_plgdiori_texinfo},
20642 {"plgdiplt",_wrap_plgdiplt,0,0,2,_wrap_plgdiplt_texinfo},
20643 {"plgfam",_wrap_plgfam,0,0,2,_wrap_plgfam_texinfo},
20644 {"plgfci",_wrap_plgfci,0,0,2,_wrap_plgfci_texinfo},
20645 {"plgfnam",_wrap_plgfnam,0,0,2,_wrap_plgfnam_texinfo},
20646 {"plgfont",_wrap_plgfont,0,0,2,_wrap_plgfont_texinfo},
20647 {"plglevel",_wrap_plglevel,0,0,2,_wrap_plglevel_texinfo},
20648 {"plgpage",_wrap_plgpage,0,0,2,_wrap_plgpage_texinfo},
20649 {"plgra",_wrap_plgra,0,0,2,_wrap_plgra_texinfo},
20650 {"plgspa",_wrap_plgspa,0,0,2,_wrap_plgspa_texinfo},
20651 {"plgstrm",_wrap_plgstrm,0,0,2,_wrap_plgstrm_texinfo},
20652 {"plgver",_wrap_plgver,0,0,2,_wrap_plgver_texinfo},
20653 {"plgvpd",_wrap_plgvpd,0,0,2,_wrap_plgvpd_texinfo},
20654 {"plgvpw",_wrap_plgvpw,0,0,2,_wrap_plgvpw_texinfo},
20655 {"plgxax",_wrap_plgxax,0,0,2,_wrap_plgxax_texinfo},
20656 {"plgyax",_wrap_plgyax,0,0,2,_wrap_plgyax_texinfo},
20657 {"plgzax",_wrap_plgzax,0,0,2,_wrap_plgzax_texinfo},
20658 {"plhist",_wrap_plhist,0,0,2,_wrap_plhist_texinfo},
20659 {"plhlsrgb",_wrap_plhlsrgb,0,0,2,_wrap_plhlsrgb_texinfo},
20660 {"plinit",_wrap_plinit,0,0,2,_wrap_plinit_texinfo},
20661 {"pljoin",_wrap_pljoin,0,0,2,_wrap_pljoin_texinfo},
20662 {"pllab",_wrap_pllab,0,0,2,_wrap_pllab_texinfo},
20663 {"pllegend",_wrap_pllegend,0,0,2,_wrap_pllegend_texinfo},
20664 {"pllightsource",_wrap_pllightsource,0,0,2,_wrap_pllightsource_texinfo},
20665 {"plline",_wrap_plline,0,0,2,_wrap_plline_texinfo},
20666 {"plline3",_wrap_plline3,0,0,2,_wrap_plline3_texinfo},
20667 {"pllsty",_wrap_pllsty,0,0,2,_wrap_pllsty_texinfo},
20668 {"plmkstrm",_wrap_plmkstrm,0,0,2,_wrap_plmkstrm_texinfo},
20669 {"plmtex",_wrap_plmtex,0,0,2,_wrap_plmtex_texinfo},
20670 {"plmtex3",_wrap_plmtex3,0,0,2,_wrap_plmtex3_texinfo},
20671 {"plparseopts",_wrap_plparseopts,0,0,2,_wrap_plparseopts_texinfo},
20672 {"plpat",_wrap_plpat,0,0,2,_wrap_plpat_texinfo},
20673 {"plpath",_wrap_plpath,0,0,2,_wrap_plpath_texinfo},
20674 {"plpoin",_wrap_plpoin,0,0,2,_wrap_plpoin_texinfo},
20675 {"plpoin3",_wrap_plpoin3,0,0,2,_wrap_plpoin3_texinfo},
20676 {"plpoly3",_wrap_plpoly3,0,0,2,_wrap_plpoly3_texinfo},
20677 {"plprec",_wrap_plprec,0,0,2,_wrap_plprec_texinfo},
20678 {"plpsty",_wrap_plpsty,0,0,2,_wrap_plpsty_texinfo},
20679 {"plptex",_wrap_plptex,0,0,2,_wrap_plptex_texinfo},
20680 {"plptex3",_wrap_plptex3,0,0,2,_wrap_plptex3_texinfo},
20681 {"plrandd",_wrap_plrandd,0,0,2,_wrap_plrandd_texinfo},
20682 {"plreplot",_wrap_plreplot,0,0,2,_wrap_plreplot_texinfo},
20683 {"plrgbhls",_wrap_plrgbhls,0,0,2,_wrap_plrgbhls_texinfo},
20684 {"plschr",_wrap_plschr,0,0,2,_wrap_plschr_texinfo},
20685 {"plscmap0",_wrap_plscmap0,0,0,2,_wrap_plscmap0_texinfo},
20686 {"plscmap0a",_wrap_plscmap0a,0,0,2,_wrap_plscmap0a_texinfo},
20687 {"plscmap0n",_wrap_plscmap0n,0,0,2,_wrap_plscmap0n_texinfo},
20688 {"plscmap1",_wrap_plscmap1,0,0,2,_wrap_plscmap1_texinfo},
20689 {"plscmap1a",_wrap_plscmap1a,0,0,2,_wrap_plscmap1a_texinfo},
20690 {"plscmap1l",_wrap_plscmap1l,0,0,2,_wrap_plscmap1l_texinfo},
20691 {"plscmap1la",_wrap_plscmap1la,0,0,2,_wrap_plscmap1la_texinfo},
20692 {"plscmap1n",_wrap_plscmap1n,0,0,2,_wrap_plscmap1n_texinfo},
20693 {"plscmap1_range",_wrap_plscmap1_range,0,0,2,0},
20694 {"plgcmap1_range",_wrap_plgcmap1_range,0,0,2,0},
20695 {"plscol0",_wrap_plscol0,0,0,2,_wrap_plscol0_texinfo},
20696 {"plscol0a",_wrap_plscol0a,0,0,2,_wrap_plscol0a_texinfo},
20697 {"plscolbg",_wrap_plscolbg,0,0,2,_wrap_plscolbg_texinfo},
20698 {"plscolbga",_wrap_plscolbga,0,0,2,_wrap_plscolbga_texinfo},
20699 {"plscolor",_wrap_plscolor,0,0,2,_wrap_plscolor_texinfo},
20700 {"plscompression",_wrap_plscompression,0,0,2,_wrap_plscompression_texinfo},
20701 {"plsdev",_wrap_plsdev,0,0,2,_wrap_plsdev_texinfo},
20702 {"plsdidev",_wrap_plsdidev,0,0,2,_wrap_plsdidev_texinfo},
20703 {"plsdimap",_wrap_plsdimap,0,0,2,_wrap_plsdimap_texinfo},
20704 {"plsdiori",_wrap_plsdiori,0,0,2,_wrap_plsdiori_texinfo},
20705 {"plsdiplt",_wrap_plsdiplt,0,0,2,_wrap_plsdiplt_texinfo},
20706 {"plsdiplz",_wrap_plsdiplz,0,0,2,_wrap_plsdiplz_texinfo},
20707 {"plseed",_wrap_plseed,0,0,2,_wrap_plseed_texinfo},
20708 {"plsesc",_wrap_plsesc,0,0,2,_wrap_plsesc_texinfo},
20709 {"plSetOpt",_wrap_plSetOpt,0,0,2,_wrap_plSetOpt_texinfo},
20710 {"plsfam",_wrap_plsfam,0,0,2,_wrap_plsfam_texinfo},
20711 {"plsfci",_wrap_plsfci,0,0,2,_wrap_plsfci_texinfo},
20712 {"plsfnam",_wrap_plsfnam,0,0,2,_wrap_plsfnam_texinfo},
20713 {"plsfont",_wrap_plsfont,0,0,2,_wrap_plsfont_texinfo},
20714 {"plslabelfunc",_wrap_plslabelfunc,0,0,2,_wrap_plslabelfunc_texinfo},
20715 {"plsmaj",_wrap_plsmaj,0,0,2,_wrap_plsmaj_texinfo},
20716 {"plsmin",_wrap_plsmin,0,0,2,_wrap_plsmin_texinfo},
20717 {"plsori",_wrap_plsori,0,0,2,_wrap_plsori_texinfo},
20718 {"plspage",_wrap_plspage,0,0,2,_wrap_plspage_texinfo},
20719 {"plspal0",_wrap_plspal0,0,0,2,_wrap_plspal0_texinfo},
20720 {"plspal1",_wrap_plspal1,0,0,2,_wrap_plspal1_texinfo},
20721 {"plspause",_wrap_plspause,0,0,2,_wrap_plspause_texinfo},
20722 {"plsstrm",_wrap_plsstrm,0,0,2,_wrap_plsstrm_texinfo},
20723 {"plssub",_wrap_plssub,0,0,2,_wrap_plssub_texinfo},
20724 {"plssym",_wrap_plssym,0,0,2,_wrap_plssym_texinfo},
20725 {"plstar",_wrap_plstar,0,0,2,_wrap_plstar_texinfo},
20726 {"plstart",_wrap_plstart,0,0,2,_wrap_plstart_texinfo},
20727 {"plstransform",_wrap_plstransform,0,0,2,_wrap_plstransform_texinfo},
20728 {"plstring",_wrap_plstring,0,0,2,_wrap_plstring_texinfo},
20729 {"plstring3",_wrap_plstring3,0,0,2,_wrap_plstring3_texinfo},
20730 {"plstripa",_wrap_plstripa,0,0,2,_wrap_plstripa_texinfo},
20731 {"plstripd",_wrap_plstripd,0,0,2,_wrap_plstripd_texinfo},
20732 {"plstyl",_wrap_plstyl,0,0,2,_wrap_plstyl_texinfo},
20733 {"plsvect",_wrap_plsvect,0,0,2,_wrap_plsvect_texinfo},
20734 {"plsvpa",_wrap_plsvpa,0,0,2,_wrap_plsvpa_texinfo},
20735 {"plsxax",_wrap_plsxax,0,0,2,_wrap_plsxax_texinfo},
20736 {"plsyax",_wrap_plsyax,0,0,2,_wrap_plsyax_texinfo},
20737 {"plsym",_wrap_plsym,0,0,2,_wrap_plsym_texinfo},
20738 {"plszax",_wrap_plszax,0,0,2,_wrap_plszax_texinfo},
20739 {"pltext",_wrap_pltext,0,0,2,_wrap_pltext_texinfo},
20740 {"pltimefmt",_wrap_pltimefmt,0,0,2,_wrap_pltimefmt_texinfo},
20741 {"plvasp",_wrap_plvasp,0,0,2,_wrap_plvasp_texinfo},
20742 {"plvpas",_wrap_plvpas,0,0,2,_wrap_plvpas_texinfo},
20743 {"plvpor",_wrap_plvpor,0,0,2,_wrap_plvpor_texinfo},
20744 {"plvsta",_wrap_plvsta,0,0,2,_wrap_plvsta_texinfo},
20745 {"plw3d",_wrap_plw3d,0,0,2,_wrap_plw3d_texinfo},
20746 {"plwidth",_wrap_plwidth,0,0,2,_wrap_plwidth_texinfo},
20747 {"plwind",_wrap_plwind,0,0,2,_wrap_plwind_texinfo},
20748 {"plxormod",_wrap_plxormod,0,0,2,_wrap_plxormod_texinfo},
20749 {"plmap",_wrap_plmap,0,0,2,_wrap_plmap_texinfo},
20750 {"plmeridians",_wrap_plmeridians,0,0,2,_wrap_plmeridians_texinfo},
20751 {"plClearOpts",_wrap_plClearOpts,0,0,2,0},
20752 {"plResetOpts",_wrap_plResetOpts,0,0,2,0},
20753 {"plSetUsage",_wrap_plSetUsage,0,0,2,0},
20754 {"plOptUsage",_wrap_plOptUsage,0,0,2,0},
20755 {0,0,0,0,0}
20756 };
20757
20758 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
20759
20760 static swig_type_info _swigt__p_PLGraphicsIn = {"_p_PLGraphicsIn", "PLGraphicsIn *", 0, 0, (void*)&_wrap_class_PLGraphicsIn, 0};
20761 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
20762 static swig_type_info _swigt__p_double = {"_p_double", "double *|PLFLT *", 0, 0, (void*)0, 0};
20763 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};
20764 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};
20765 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};
20766 static swig_type_info _swigt__p_int = {"_p_int", "PLBOOL *|int *|PLINT *", 0, 0, (void*)0, 0};
20767 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
20768 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|PLUNICODE *", 0, 0, (void*)0, 0};
20769
20770 static swig_type_info *swig_type_initial[] = {
20771 &_swigt__p_PLGraphicsIn,
20772 &_swigt__p_char,
20773 &_swigt__p_double,
20774 &_swigt__p_f_double_double_p_double_p_double_p_void__void,
20775 &_swigt__p_f_int_double_p_char_int_p_void__void,
20776 &_swigt__p_f_int_p_double_p_double__void,
20777 &_swigt__p_int,
20778 &_swigt__p_p_char,
20779 &_swigt__p_unsigned_int,
20780 };
20781
20782 static swig_cast_info _swigc__p_PLGraphicsIn[] = { {&_swigt__p_PLGraphicsIn, 0, 0, 0},{0, 0, 0, 0}};
20783 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
20784 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
20785 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}};
20786 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}};
20787 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}};
20788 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
20789 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
20790 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
20791
20792 static swig_cast_info *swig_cast_initial[] = {
20793 _swigc__p_PLGraphicsIn,
20794 _swigc__p_char,
20795 _swigc__p_double,
20796 _swigc__p_f_double_double_p_double_p_double_p_void__void,
20797 _swigc__p_f_int_double_p_char_int_p_void__void,
20798 _swigc__p_f_int_p_double_p_double__void,
20799 _swigc__p_int,
20800 _swigc__p_p_char,
20801 _swigc__p_unsigned_int,
20802 };
20803
20804
20805 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
20806
20807 /* -----------------------------------------------------------------------------
20808 * Type initialization:
20809 * This problem is tough by the requirement that no dynamic
20810 * memory is used. Also, since swig_type_info structures store pointers to
20811 * swig_cast_info structures and swig_cast_info structures store pointers back
20812 * to swig_type_info structures, we need some lookup code at initialization.
20813 * The idea is that swig generates all the structures that are needed.
20814 * The runtime then collects these partially filled structures.
20815 * The SWIG_InitializeModule function takes these initial arrays out of
20816 * swig_module, and does all the lookup, filling in the swig_module.types
20817 * array with the correct data and linking the correct swig_cast_info
20818 * structures together.
20819 *
20820 * The generated swig_type_info structures are assigned staticly to an initial
20821 * array. We just loop through that array, and handle each type individually.
20822 * First we lookup if this type has been already loaded, and if so, use the
20823 * loaded structure instead of the generated one. Then we have to fill in the
20824 * cast linked list. The cast data is initially stored in something like a
20825 * two-dimensional array. Each row corresponds to a type (there are the same
20826 * number of rows as there are in the swig_type_initial array). Each entry in
20827 * a column is one of the swig_cast_info structures for that type.
20828 * The cast_initial array is actually an array of arrays, because each row has
20829 * a variable number of columns. So to actually build the cast linked list,
20830 * we find the array of casts associated with the type, and loop through it
20831 * adding the casts to the list. The one last trick we need to do is making
20832 * sure the type pointer in the swig_cast_info struct is correct.
20833 *
20834 * First off, we lookup the cast->type name to see if it is already loaded.
20835 * There are three cases to handle:
20836 * 1) If the cast->type has already been loaded AND the type we are adding
20837 * casting info to has not been loaded (it is in this module), THEN we
20838 * replace the cast->type pointer with the type pointer that has already
20839 * been loaded.
20840 * 2) If BOTH types (the one we are adding casting info to, and the
20841 * cast->type) are loaded, THEN the cast info has already been loaded by
20842 * the previous module so we just ignore it.
20843 * 3) Finally, if cast->type has not already been loaded, then we add that
20844 * swig_cast_info to the linked list (because the cast->type) pointer will
20845 * be correct.
20846 * ----------------------------------------------------------------------------- */
20847
20848 #ifdef __cplusplus
20849 extern "C" {
20850 #if 0
20851 } /* c-mode */
20852 #endif
20853 #endif
20854
20855 #if 0
20856 #define SWIGRUNTIME_DEBUG
20857 #endif
20858
20859
20860 SWIGRUNTIME void
20861 SWIG_InitializeModule(void *clientdata) {
20862 size_t i;
20863 swig_module_info *module_head, *iter;
20864 int found, init;
20865
20866 clientdata = clientdata;
20867
20868 /* check to see if the circular list has been setup, if not, set it up */
20869 if (swig_module.next==0) {
20870 /* Initialize the swig_module */
20871 swig_module.type_initial = swig_type_initial;
20872 swig_module.cast_initial = swig_cast_initial;
20873 swig_module.next = &swig_module;
20874 init = 1;
20875 } else {
20876 init = 0;
20877 }
20878
20879 /* Try and load any already created modules */
20880 module_head = SWIG_GetModule(clientdata);
20881 if (!module_head) {
20882 /* This is the first module loaded for this interpreter */
20883 /* so set the swig module into the interpreter */
20884 SWIG_SetModule(clientdata, &swig_module);
20885 module_head = &swig_module;
20886 } else {
20887 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
20888 found=0;
20889 iter=module_head;
20890 do {
20891 if (iter==&swig_module) {
20892 found=1;
20893 break;
20894 }
20895 iter=iter->next;
20896 } while (iter!= module_head);
20897
20898 /* if the is found in the list, then all is done and we may leave */
20899 if (found) return;
20900 /* otherwise we must add out module into the list */
20901 swig_module.next = module_head->next;
20902 module_head->next = &swig_module;
20903 }
20904
20905 /* When multiple interpeters are used, a module could have already been initialized in
20906 a different interpreter, but not yet have a pointer in this interpreter.
20907 In this case, we do not want to continue adding types... everything should be
20908 set up already */
20909 if (init == 0) return;
20910
20911 /* Now work on filling in swig_module.types */
20912 #ifdef SWIGRUNTIME_DEBUG
20913 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
20914 #endif
20915 for (i = 0; i < swig_module.size; ++i) {
20916 swig_type_info *type = 0;
20917 swig_type_info *ret;
20918 swig_cast_info *cast;
20919
20920 #ifdef SWIGRUNTIME_DEBUG
20921 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20922 #endif
20923
20924 /* if there is another module already loaded */
20925 if (swig_module.next != &swig_module) {
20926 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
20927 }
20928 if (type) {
20929 /* Overwrite clientdata field */
20930 #ifdef SWIGRUNTIME_DEBUG
20931 printf("SWIG_InitializeModule: found type %s\n", type->name);
20932 #endif
20933 if (swig_module.type_initial[i]->clientdata) {
20934 type->clientdata = swig_module.type_initial[i]->clientdata;
20935 #ifdef SWIGRUNTIME_DEBUG
20936 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
20937 #endif
20938 }
20939 } else {
20940 type = swig_module.type_initial[i];
20941 }
20942
20943 /* Insert casting types */
20944 cast = swig_module.cast_initial[i];
20945 while (cast->type) {
20946
20947 /* Don't need to add information already in the list */
20948 ret = 0;
20949 #ifdef SWIGRUNTIME_DEBUG
20950 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
20951 #endif
20952 if (swig_module.next != &swig_module) {
20953 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
20954 #ifdef SWIGRUNTIME_DEBUG
20955 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
20956 #endif
20957 }
20958 if (ret) {
20959 if (type == swig_module.type_initial[i]) {
20960 #ifdef SWIGRUNTIME_DEBUG
20961 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
20962 #endif
20963 cast->type = ret;
20964 ret = 0;
20965 } else {
20966 /* Check for casting already in the list */
20967 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
20968 #ifdef SWIGRUNTIME_DEBUG
20969 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
20970 #endif
20971 if (!ocast) ret = 0;
20972 }
20973 }
20974
20975 if (!ret) {
20976 #ifdef SWIGRUNTIME_DEBUG
20977 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
20978 #endif
20979 if (type->cast) {
20980 type->cast->prev = cast;
20981 cast->next = type->cast;
20982 }
20983 type->cast = cast;
20984 }
20985 cast++;
20986 }
20987 /* Set entry in modules->types array equal to the type */
20988 swig_module.types[i] = type;
20989 }
20990 swig_module.types[i] = 0;
20991
20992 #ifdef SWIGRUNTIME_DEBUG
20993 printf("**** SWIG_InitializeModule: Cast List ******\n");
20994 for (i = 0; i < swig_module.size; ++i) {
20995 int j = 0;
20996 swig_cast_info *cast = swig_module.cast_initial[i];
20997 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20998 while (cast->type) {
20999 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
21000 cast++;
21001 ++j;
21002 }
21003 printf("---- Total casts: %d\n",j);
21004 }
21005 printf("**** SWIG_InitializeModule: Cast List ******\n");
21006 #endif
21007 }
21008
21009 /* This function will propagate the clientdata field of type to
21010 * any new swig_type_info structures that have been added into the list
21011 * of equivalent types. It is like calling
21012 * SWIG_TypeClientData(type, clientdata) a second time.
21013 */
21014 SWIGRUNTIME void
21015 SWIG_PropagateClientData(void) {
21016 size_t i;
21017 swig_cast_info *equiv;
21018 static int init_run = 0;
21019
21020 if (init_run) return;
21021 init_run = 1;
21022
21023 for (i = 0; i < swig_module.size; i++) {
21024 if (swig_module.types[i]->clientdata) {
21025 equiv = swig_module.types[i]->cast;
21026 while (equiv) {
21027 if (!equiv->converter) {
21028 if (equiv->type && !equiv->type->clientdata)
21029 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
21030 }
21031 equiv = equiv->next;
21032 }
21033 }
21034 }
21035 }
21036
21037 #ifdef __cplusplus
21038 #if 0
21039 { /* c-mode */
21040 #endif
21041 }
21042 #endif
21043
21044
21045
21046 static void SWIG_init_user(octave_swig_type* module_ns);
21047
21048 SWIGINTERN void SWIG_Octave_InstallFunction(octave_function *octloadfcn, std::string name) {
21049 octave_value_list args;
21050 args.append(name);
21051 args.append(octloadfcn->fcn_file_name());
21052 feval("autoload", args, 0);
21053 }
21054
21055 static const char *const subclass_usage = "-*- texinfo -*- \n\
21056 @deftypefn {Loadable Function} {} subclass()\n\
21057 @deftypefnx{Loadable Function} {} subclass(@var{swigclass}, @var{name}, @var{fcn}, @dots{})\n\
21058 Subclass a C++ class from within Octave, and provide implementations of its virtual methods.\n\
21059 \n\
21060 See the SWIG manual for usage examples.\n\
21061 @end deftypefn";
21062
21063 DEFUN_DLD( subclass, args, nargout, subclass_usage ) {
21064 octave_swig_type *top = new octave_swig_type;
21065 for (int j = 0; j < args.length(); ++j) {
21066 if (args(j).type_id() == octave_swig_ref::static_type_id()) {
21067 octave_swig_ref *osr = static_cast < octave_swig_ref *>(args(j).internal_rep());
21068 octave_swig_type *ost = osr->get_ptr();
21069 if (!ost->is_owned()) {
21070 error("cannot subclass object not constructed on octave side");
21071 return octave_value_list();
21072 }
21073 top->merge(*ost);
21074 } else if (args(j).is_function_handle()) {
21075 top->assign(args(j).fcn_handle_value()->fcn_name(), args(j));
21076 } else if (args(j).is_string()) {
21077 if (j + 1 >= args.length()) {
21078 error("member assignments must be of string,value form");
21079 return octave_value_list();
21080 }
21081 top->assign(args(j).string_value(), args(j + 1));
21082 ++j;
21083 } else {
21084 error("invalid arguments to subclass()");
21085 return octave_value_list();
21086 }
21087 }
21088 return octave_value(Swig::swig_value_ref(top));
21089 }
21090
21091 static const char *const swig_type_usage = "-*- texinfo -*- \n\
21092 @deftypefn {Loadable Function} {} swig_type(@var{swigref})\n\
21093 Return the underlying C/C++ type name of a SWIG-wrapped object.\n\
21094 @end deftypefn";
21095
21096 DEFUN_DLD( swig_type, args, nargout, swig_type_usage ) {
21097 if (args.length() != 1) {
21098 error("swig_type() must be called with only a single object");
21099 return octave_value_list();
21100 }
21101 octave_swig_type *ost = Swig::swig_value_deref(args(0));
21102 if (!ost) {
21103 error("object is not a swig_ref");
21104 return octave_value_list();
21105 }
21106 return octave_value(ost->swig_type_name());
21107 }
21108
21109 static const char *const swig_typequery_usage = "-*- texinfo -*- \n\
21110 @deftypefn {Loadable Function} {} swig_typequery(@var{string})\n\
21111 Return @var{string} if it is a recognised SWIG-wrapped C/C++ type name;\n\
21112 otherwise return `<unknown>'.\n\
21113 @end deftypefn";
21114
21115 DEFUN_DLD( swig_typequery, args, nargout, swig_typequery_usage ) {
21116 if (args.length() != 1 || !args(0).is_string()) {
21117 error("swig_typequery() must be called with single string argument");
21118 return octave_value_list();
21119 }
21120 swig_module_info *module = SWIG_GetModule(0);
21121 swig_type_info *type = SWIG_TypeQueryModule(module, module, args(0).string_value().c_str());
21122 if (!type)
21123 return octave_value("<unknown>");
21124 return octave_value(type->name);
21125 }
21126
21127 static const char *const swig_this_usage = "-*- texinfo -*- \n\
21128 @deftypefn {Loadable Function} {} swig_this(@var{swigref})\n\
21129 Return the underlying C/C++ pointer of a SWIG-wrapped object.\n\
21130 @end deftypefn";
21131
21132 DEFUN_DLD( swig_this, args, nargout, swig_this_usage ) {
21133 if (args.length() != 1) {
21134 error("swig_this() must be called with only a single object");
21135 return octave_value_list();
21136 }
21137 if (args(0).is_matrix_type() && args(0).rows() == 0 && args(0).columns() == 0)
21138 return octave_value(octave_uint64(0));
21139 octave_swig_type *ost = Swig::swig_value_deref(args(0));
21140 if (!ost) {
21141 error("object is not a swig_ref");
21142 return octave_value_list();
21143 }
21144 return octave_value(octave_uint64((unsigned long long) ost->swig_this()));
21145 }
21146
21147 // workaround to prevent octave seg-faulting on exit: register at-exit
21148 // function which exits octave immediately without trying to cleanup memory.
21149 // definitely affects version 3.2.*, not sure about 3.3.*, seems to be
21150 // fixed in version 3.4.* and above. can be turned on/off with macros.
21151 #ifndef SWIG_OCTAVE_NO_SEGFAULT_HACK
21152 #if 36 < OCTAVE_API_VERSION_NUMBER && OCTAVE_API_VERSION_NUMBER < 45
21153 #define SWIG_OCTAVE_SEGFAULT_HACK
21154 #endif
21155 #endif
21156 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
21157 #define _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) SWIG_OCT_SEGF_HACK_ATEXIT_FCN_##NAME
21158 #define SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME) _SWIG_OCT_SEGF_HACK_ATEXIT_FCN(NAME)
21159 void SWIG_OCT_SEGF_HACK_ATEXIT_FCN(SWIG_name)(void) {
21160 _exit(exit_status);
21161 }
21162 #endif
21163
21164 static const char *const SWIG_name_usage = "-*- texinfo -*- \n\
21165 @deftypefn {Loadable Module} {} " SWIG_name_d "\n\
21166 Loads the SWIG-generated module `" SWIG_name_d "'.\n\
21167 \n\
21168 To load the module into the global namespace:\n\
21169 @example\n\
21170 " SWIG_name_d ";\n\
21171 @end example\n\
21172 To access the module through a local variable, without loading it globally:\n\
21173 @example\n\
21174 " SWIG_name_d " = " SWIG_name_d ";\n\
21175 @end example\n\
21176 To access the module locally through a variable named, e.g. @var{modl}:\n\
21177 @example\n\
21178 @var{modl} = " SWIG_name_d ";\n\
21179 @end example\n\
21180 @end deftypefn";
21181
21182 DEFUN_DLD( SWIG_name, args, nargout, SWIG_name_usage ) {
21183
21184 static octave_swig_type* module_ns = 0;
21185 octave_value_list retval;
21186
21187 // create module on first function call
21188 if (!module_ns) {
21189
21190 #ifdef SWIG_OCTAVE_SEGFAULT_HACK
21191 atexit(SWIG_OCT_SEGF_HACK_ATEXIT_FCN(SWIG_name));
21192 #endif
21193
21194 // workaround bug in octave where installing global variable of custom type and then
21195 // exiting without explicitly clearing the variable causes octave to segfault.
21196 #if OCTAVE_API_VERSION_NUMBER >= 37
21197 octave_value_list eval_args;
21198 eval_args.append("base");
21199 eval_args.append("function __swig_atexit__; "
21200 " if mislocked() "
21201 " clear -all; "
21202 " else "
21203 " mlock(); "
21204 " endif; "
21205 "endfunction; "
21206 "__swig_atexit__; "
21207 "atexit(\"__swig_atexit__\", false); "
21208 "atexit(\"__swig_atexit__\")");
21209 feval("evalin", eval_args, 0);
21210 #endif
21211
21212 octave_swig_ref::register_type();
21213 octave_swig_packed::register_type();
21214 SWIG_InitializeModule(0);
21215 SWIG_PropagateClientData();
21216
21217 octave_function *me = octave_call_stack::current();
21218
21219 SWIG_Octave_InstallFunction(me, "swig_type");
21220 SWIG_Octave_InstallFunction(me, "swig_typequery");
21221 SWIG_Octave_InstallFunction(me, "swig_this");
21222 SWIG_Octave_InstallFunction(me, "subclass");
21223
21224 octave_swig_type* cvar_ns=0;
21225 if (std::string(SWIG_global_name) != ".") {
21226 cvar_ns=new octave_swig_type;
21227 for (int j=0;swig_globals[j].name;++j)
21228 if (swig_globals[j].get_method)
21229 cvar_ns->assign(swig_globals[j].name,&swig_globals[j]);
21230 }
21231
21232 module_ns=new octave_swig_type(0, 0, 0, true);
21233 if (std::string(SWIG_global_name) != ".") {
21234 module_ns->assign(SWIG_global_name,Swig::swig_value_ref(cvar_ns));
21235 }
21236 else {
21237 for (int j=0;swig_globals[j].name;++j)
21238 if (swig_globals[j].get_method)
21239 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
21240 }
21241 for (int j=0;swig_globals[j].name;++j)
21242 if (swig_globals[j].method)
21243 module_ns->assign(swig_globals[j].name,&swig_globals[j]);
21244
21245 // * need better solution here; swig_type -> octave_class mapping is
21246 // * really n-to-1, in some cases such as template partial spec, etc.
21247 // * see failing tests.
21248 for (int j=0;swig_types[j];++j)
21249 if (swig_types[j]->clientdata) {
21250 swig_octave_class* c=(swig_octave_class*)swig_types[j]->clientdata;
21251 module_ns->assign(c->name,
21252 Swig::swig_value_ref
21253 (new octave_swig_type(0,swig_types[j])));
21254 }
21255
21256 SWIG_init_user(module_ns);
21257
21258 SWIG_InstallOps(octave_swig_ref::static_type_id());
21259
21260 #if OCTAVE_API_VERSION_NUMBER < 37
21261 mlock(me->name());
21262 #else
21263 mlock();
21264 #endif
21265
21266 }
21267
21268 // return module if asked for
21269 if (args.length() == 0 && nargout == 1) {
21270 retval = octave_value(module_ns->as_value());
21271 }
21272
21273 // if call with not output arguments, load globally
21274 else if (args.length() == 0 && nargout == 0) {
21275
21276 octave_function *me = octave_call_stack::current();
21277
21278 octave_swig_type::swig_member_const_iterator mb;
21279 for (mb = module_ns->swig_members_begin(); mb != module_ns->swig_members_end(); ++mb) {
21280 if (mb->second.first && mb->second.first->method) {
21281 SWIG_Octave_InstallFunction(me, mb->first);
21282 }
21283 else if (mb->second.second.is_defined()) {
21284 SWIG_Octave_SetGlobalValue(mb->first, mb->second.second);
21285 SWIG_Octave_LinkGlobalValue(mb->first);
21286 }
21287 }
21288
21289 SWIG_Octave_SetGlobalValue(SWIG_name_d, module_ns->as_value());
21290 SWIG_Octave_LinkGlobalValue(SWIG_name_d);
21291
21292 }
21293
21294 // otherwise print usage
21295 else {
21296 print_usage();
21297 }
21298
21299 return retval;
21300
21301 }
21302
21303
21304 static void SWIG_init_user(octave_swig_type* module_ns)
21305 {
21306 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_RGB",SWIG_From_int((int)(1)));
21307 SWIG_Octave_SetConstant(module_ns,"PLESC_ALLOC_NCOL",SWIG_From_int((int)(2)));
21308 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_LPB",SWIG_From_int((int)(3)));
21309 SWIG_Octave_SetConstant(module_ns,"PLESC_EXPOSE",SWIG_From_int((int)(4)));
21310 SWIG_Octave_SetConstant(module_ns,"PLESC_RESIZE",SWIG_From_int((int)(5)));
21311 SWIG_Octave_SetConstant(module_ns,"PLESC_REDRAW",SWIG_From_int((int)(6)));
21312 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT",SWIG_From_int((int)(7)));
21313 SWIG_Octave_SetConstant(module_ns,"PLESC_GRAPH",SWIG_From_int((int)(8)));
21314 SWIG_Octave_SetConstant(module_ns,"PLESC_FILL",SWIG_From_int((int)(9)));
21315 SWIG_Octave_SetConstant(module_ns,"PLESC_DI",SWIG_From_int((int)(10)));
21316 SWIG_Octave_SetConstant(module_ns,"PLESC_FLUSH",SWIG_From_int((int)(11)));
21317 SWIG_Octave_SetConstant(module_ns,"PLESC_EH",SWIG_From_int((int)(12)));
21318 SWIG_Octave_SetConstant(module_ns,"PLESC_GETC",SWIG_From_int((int)(13)));
21319 SWIG_Octave_SetConstant(module_ns,"PLESC_SWIN",SWIG_From_int((int)(14)));
21320 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING",SWIG_From_int((int)(15)));
21321 SWIG_Octave_SetConstant(module_ns,"PLESC_XORMOD",SWIG_From_int((int)(16)));
21322 SWIG_Octave_SetConstant(module_ns,"PLESC_SET_COMPRESSION",SWIG_From_int((int)(17)));
21323 SWIG_Octave_SetConstant(module_ns,"PLESC_CLEAR",SWIG_From_int((int)(18)));
21324 SWIG_Octave_SetConstant(module_ns,"PLESC_DASH",SWIG_From_int((int)(19)));
21325 SWIG_Octave_SetConstant(module_ns,"PLESC_HAS_TEXT",SWIG_From_int((int)(20)));
21326 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGE",SWIG_From_int((int)(21)));
21327 SWIG_Octave_SetConstant(module_ns,"PLESC_IMAGEOPS",SWIG_From_int((int)(22)));
21328 SWIG_Octave_SetConstant(module_ns,"PLESC_PL2DEVCOL",SWIG_From_int((int)(23)));
21329 SWIG_Octave_SetConstant(module_ns,"PLESC_DEV2PLCOL",SWIG_From_int((int)(24)));
21330 SWIG_Octave_SetConstant(module_ns,"PLESC_SETBGFG",SWIG_From_int((int)(25)));
21331 SWIG_Octave_SetConstant(module_ns,"PLESC_DEVINIT",SWIG_From_int((int)(26)));
21332 SWIG_Octave_SetConstant(module_ns,"PLESC_GETBACKEND",SWIG_From_int((int)(27)));
21333 SWIG_Octave_SetConstant(module_ns,"PLESC_BEGIN_TEXT",SWIG_From_int((int)(28)));
21334 SWIG_Octave_SetConstant(module_ns,"PLESC_TEXT_CHAR",SWIG_From_int((int)(29)));
21335 SWIG_Octave_SetConstant(module_ns,"PLESC_CONTROL_CHAR",SWIG_From_int((int)(30)));
21336 SWIG_Octave_SetConstant(module_ns,"PLESC_END_TEXT",SWIG_From_int((int)(31)));
21337 SWIG_Octave_SetConstant(module_ns,"PLESC_START_RASTERIZE",SWIG_From_int((int)(32)));
21338 SWIG_Octave_SetConstant(module_ns,"PLESC_END_RASTERIZE",SWIG_From_int((int)(33)));
21339 SWIG_Octave_SetConstant(module_ns,"PLESC_ARC",SWIG_From_int((int)(34)));
21340 SWIG_Octave_SetConstant(module_ns,"PLESC_GRADIENT",SWIG_From_int((int)(35)));
21341 SWIG_Octave_SetConstant(module_ns,"PLESC_MODESET",SWIG_From_int((int)(36)));
21342 SWIG_Octave_SetConstant(module_ns,"PLESC_MODEGET",SWIG_From_int((int)(37)));
21343 SWIG_Octave_SetConstant(module_ns,"PLTEXT_FONTCHANGE",SWIG_From_int((int)(0)));
21344 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUPERSCRIPT",SWIG_From_int((int)(1)));
21345 SWIG_Octave_SetConstant(module_ns,"PLTEXT_SUBSCRIPT",SWIG_From_int((int)(2)));
21346 SWIG_Octave_SetConstant(module_ns,"PLTEXT_BACKCHAR",SWIG_From_int((int)(3)));
21347 SWIG_Octave_SetConstant(module_ns,"PLTEXT_OVERLINE",SWIG_From_int((int)(4)));
21348 SWIG_Octave_SetConstant(module_ns,"PLTEXT_UNDERLINE",SWIG_From_int((int)(5)));
21349 SWIG_Octave_SetConstant(module_ns,"ZEROW2B",SWIG_From_int((int)(1)));
21350 SWIG_Octave_SetConstant(module_ns,"ZEROW2D",SWIG_From_int((int)(2)));
21351 SWIG_Octave_SetConstant(module_ns,"ONEW2B",SWIG_From_int((int)(3)));
21352 SWIG_Octave_SetConstant(module_ns,"ONEW2D",SWIG_From_int((int)(4)));
21353 SWIG_Octave_SetConstant(module_ns,"PLSWIN_DEVICE",SWIG_From_int((int)(1)));
21354 SWIG_Octave_SetConstant(module_ns,"PLSWIN_WORLD",SWIG_From_int((int)(2)));
21355 SWIG_Octave_SetConstant(module_ns,"PL_X_AXIS",SWIG_From_int((int)(1)));
21356 SWIG_Octave_SetConstant(module_ns,"PL_Y_AXIS",SWIG_From_int((int)(2)));
21357 SWIG_Octave_SetConstant(module_ns,"PL_Z_AXIS",SWIG_From_int((int)(3)));
21358 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ENABLED",SWIG_From_int((int)(0x0001)));
21359 SWIG_Octave_SetConstant(module_ns,"PL_OPT_ARG",SWIG_From_int((int)(0x0002)));
21360 SWIG_Octave_SetConstant(module_ns,"PL_OPT_NODELETE",SWIG_From_int((int)(0x0004)));
21361 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INVISIBLE",SWIG_From_int((int)(0x0008)));
21362 SWIG_Octave_SetConstant(module_ns,"PL_OPT_DISABLED",SWIG_From_int((int)(0x0010)));
21363 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FUNC",SWIG_From_int((int)(0x0100)));
21364 SWIG_Octave_SetConstant(module_ns,"PL_OPT_BOOL",SWIG_From_int((int)(0x0200)));
21365 SWIG_Octave_SetConstant(module_ns,"PL_OPT_INT",SWIG_From_int((int)(0x0400)));
21366 SWIG_Octave_SetConstant(module_ns,"PL_OPT_FLOAT",SWIG_From_int((int)(0x0800)));
21367 SWIG_Octave_SetConstant(module_ns,"PL_OPT_STRING",SWIG_From_int((int)(0x1000)));
21368 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_PARTIAL",SWIG_From_int((int)(0x0000)));
21369 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_FULL",SWIG_From_int((int)(0x0001)));
21370 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_QUIET",SWIG_From_int((int)(0x0002)));
21371 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODELETE",SWIG_From_int((int)(0x0004)));
21372 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SHOWALL",SWIG_From_int((int)(0x0008)));
21373 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_OVERRIDE",SWIG_From_int((int)(0x0010)));
21374 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NOPROGRAM",SWIG_From_int((int)(0x0020)));
21375 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_NODASH",SWIG_From_int((int)(0x0040)));
21376 SWIG_Octave_SetConstant(module_ns,"PL_PARSE_SKIP",SWIG_From_int((int)(0x0080)));
21377 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MARK",SWIG_From_int((int)(0x80000000)));
21378 SWIG_Octave_SetConstant(module_ns,"PL_FCI_IMPOSSIBLE",SWIG_From_int((int)(0x00000000)));
21379 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXDIGIT_MASK",SWIG_From_int((int)(0xf)));
21380 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_MASK",SWIG_From_int((int)(0x7)));
21381 SWIG_Octave_SetConstant(module_ns,"PL_FCI_HEXPOWER_IMPOSSIBLE",SWIG_From_int((int)(0xf)));
21382 SWIG_Octave_SetConstant(module_ns,"PL_FCI_FAMILY",SWIG_From_int((int)(0x0)));
21383 SWIG_Octave_SetConstant(module_ns,"PL_FCI_STYLE",SWIG_From_int((int)(0x1)));
21384 SWIG_Octave_SetConstant(module_ns,"PL_FCI_WEIGHT",SWIG_From_int((int)(0x2)));
21385 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SANS",SWIG_From_int((int)(0x0)));
21386 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SERIF",SWIG_From_int((int)(0x1)));
21387 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MONO",SWIG_From_int((int)(0x2)));
21388 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SCRIPT",SWIG_From_int((int)(0x3)));
21389 SWIG_Octave_SetConstant(module_ns,"PL_FCI_SYMBOL",SWIG_From_int((int)(0x4)));
21390 SWIG_Octave_SetConstant(module_ns,"PL_FCI_UPRIGHT",SWIG_From_int((int)(0x0)));
21391 SWIG_Octave_SetConstant(module_ns,"PL_FCI_ITALIC",SWIG_From_int((int)(0x1)));
21392 SWIG_Octave_SetConstant(module_ns,"PL_FCI_OBLIQUE",SWIG_From_int((int)(0x2)));
21393 SWIG_Octave_SetConstant(module_ns,"PL_FCI_MEDIUM",SWIG_From_int((int)(0x0)));
21394 SWIG_Octave_SetConstant(module_ns,"PL_FCI_BOLD",SWIG_From_int((int)(0x1)));
21395 SWIG_Octave_SetConstant(module_ns,"PL_MAXKEY",SWIG_From_int((int)(16)));
21396 SWIG_Octave_SetConstant(module_ns,"PL_MAXWINDOWS",SWIG_From_int((int)(64)));
21397 SWIG_Octave_SetConstant(module_ns,"PL_NOTSET",SWIG_From_int((int)((-42))));
21398 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_ENABLE",SWIG_From_int((int)(1)));
21399 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_DISABLE",SWIG_From_int((int)(2)));
21400 SWIG_Octave_SetConstant(module_ns,"PLESC_DOUBLEBUFFERING_QUERY",SWIG_From_int((int)(3)));
21401 SWIG_Octave_SetConstant(module_ns,"PL_BIN_DEFAULT",SWIG_From_int((int)(0x0)));
21402 SWIG_Octave_SetConstant(module_ns,"PL_BIN_CENTRED",SWIG_From_int((int)(0x1)));
21403 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEXPAND",SWIG_From_int((int)(0x2)));
21404 SWIG_Octave_SetConstant(module_ns,"PL_BIN_NOEMPTY",SWIG_From_int((int)(0x4)));
21405 SWIG_Octave_SetConstant(module_ns,"GRID_CSA",SWIG_From_int((int)(1)));
21406 SWIG_Octave_SetConstant(module_ns,"GRID_DTLI",SWIG_From_int((int)(2)));
21407 SWIG_Octave_SetConstant(module_ns,"GRID_NNI",SWIG_From_int((int)(3)));
21408 SWIG_Octave_SetConstant(module_ns,"GRID_NNIDW",SWIG_From_int((int)(4)));
21409 SWIG_Octave_SetConstant(module_ns,"GRID_NNLI",SWIG_From_int((int)(5)));
21410 SWIG_Octave_SetConstant(module_ns,"GRID_NNAIDW",SWIG_From_int((int)(6)));
21411 SWIG_Octave_SetConstant(module_ns,"PL_HIST_DEFAULT",SWIG_From_int((int)(0x00)));
21412 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOSCALING",SWIG_From_int((int)(0x01)));
21413 SWIG_Octave_SetConstant(module_ns,"PL_HIST_IGNORE_OUTLIERS",SWIG_From_int((int)(0x02)));
21414 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEXPAND",SWIG_From_int((int)(0x08)));
21415 SWIG_Octave_SetConstant(module_ns,"PL_HIST_NOEMPTY",SWIG_From_int((int)(0x10)));
21416 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_LEFT",SWIG_From_int((int)(0x1)));
21417 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_RIGHT",SWIG_From_int((int)(0x2)));
21418 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_TOP",SWIG_From_int((int)(0x4)));
21419 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_BOTTOM",SWIG_From_int((int)(0x8)));
21420 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_INSIDE",SWIG_From_int((int)(0x10)));
21421 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_OUTSIDE",SWIG_From_int((int)(0x20)));
21422 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_VIEWPORT",SWIG_From_int((int)(0x40)));
21423 SWIG_Octave_SetConstant(module_ns,"PL_POSITION_SUBPAGE",SWIG_From_int((int)(0x80)));
21424 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_NONE",SWIG_From_int((int)(0x1)));
21425 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_COLOR_BOX",SWIG_From_int((int)(0x2)));
21426 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_LINE",SWIG_From_int((int)(0x4)));
21427 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_SYMBOL",SWIG_From_int((int)(0x8)));
21428 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_TEXT_LEFT",SWIG_From_int((int)(0x10)));
21429 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BACKGROUND",SWIG_From_int((int)(0x20)));
21430 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_BOUNDING_BOX",SWIG_From_int((int)(0x40)));
21431 SWIG_Octave_SetConstant(module_ns,"PL_LEGEND_ROW_MAJOR",SWIG_From_int((int)(0x80)));
21432 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_LEFT",SWIG_From_int((int)(0x1)));
21433 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_RIGHT",SWIG_From_int((int)(0x2)));
21434 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_TOP",SWIG_From_int((int)(0x4)));
21435 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_LABEL_BOTTOM",SWIG_From_int((int)(0x8)));
21436 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_IMAGE",SWIG_From_int((int)(0x10)));
21437 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE",SWIG_From_int((int)(0x20)));
21438 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_GRADIENT",SWIG_From_int((int)(0x40)));
21439 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_NONE",SWIG_From_int((int)(0x80)));
21440 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_LOW",SWIG_From_int((int)(0x100)));
21441 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_CAP_HIGH",SWIG_From_int((int)(0x200)));
21442 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_SHADE_LABEL",SWIG_From_int((int)(0x400)));
21443 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_RIGHT",SWIG_From_int((int)(0x800)));
21444 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_TOP",SWIG_From_int((int)(0x1000)));
21445 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_LEFT",SWIG_From_int((int)(0x2000)));
21446 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_ORIENT_BOTTOM",SWIG_From_int((int)(0x4000)));
21447 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BACKGROUND",SWIG_From_int((int)(0x8000)));
21448 SWIG_Octave_SetConstant(module_ns,"PL_COLORBAR_BOUNDING_BOX",SWIG_From_int((int)(0x10000)));
21449 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_UNKNOWN",SWIG_From_int((int)(0x0)));
21450 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_DEFAULT",SWIG_From_int((int)(0x1)));
21451 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_REPLACE",SWIG_From_int((int)(0x2)));
21452 SWIG_Octave_SetConstant(module_ns,"PL_DRAWMODE_XOR",SWIG_From_int((int)(0x4)));
21453 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEX",SWIG_From_int((int)(0x001)));
21454 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEY",SWIG_From_int((int)(0x002)));
21455 SWIG_Octave_SetConstant(module_ns,"DRAW_LINEXY",SWIG_From_int((int)(0x003)));
21456 SWIG_Octave_SetConstant(module_ns,"MAG_COLOR",SWIG_From_int((int)(0x004)));
21457 SWIG_Octave_SetConstant(module_ns,"BASE_CONT",SWIG_From_int((int)(0x008)));
21458 SWIG_Octave_SetConstant(module_ns,"TOP_CONT",SWIG_From_int((int)(0x010)));
21459 SWIG_Octave_SetConstant(module_ns,"SURF_CONT",SWIG_From_int((int)(0x020)));
21460 SWIG_Octave_SetConstant(module_ns,"DRAW_SIDES",SWIG_From_int((int)(0x040)));
21461 SWIG_Octave_SetConstant(module_ns,"FACETED",SWIG_From_int((int)(0x080)));
21462 SWIG_Octave_SetConstant(module_ns,"MESH",SWIG_From_int((int)(0x100)));
21463 }
21464